Ich Probier jetzt scho an die 10h an diesem Problem rum hab es auch schon mit 3 Buffern versucht und was weiß ich sonst noch was, bringt nichts. Wäre nett wenn ihr mir sagen könntet wo mein Fehler liegt.

Hier noch der Quellcode
Soundin.h

#ifndef _SOUNDIN_H_
#define _SOUNDIN_H_

class soundin {
  public:    
    bool recording;
    bool init_done;
    char fault[256];
    int BufferSize; //Record @ 60 FPS
    int SampleRate;
    short int fps;
    short int *buffer1;//Buffer 1
    short int *buffer2;//Buffer 2
    short int *buffer3;//Buffer 3
    DWORD WINAPI (*CallbackFunc)(LPVOID arg);
    float LastDataBlock,CurrentDataBlock,DataBlockNormTime,TimeDifference;

    FILE *debugtxt;

    HWAVEIN      InputDevice;
    WAVEFORMATEX format;
    WAVEHDR      WaveInHdr1;
    WAVEHDR      WaveInHdr2;
    MMRESULT     result;
    DWORD       CallbackThread;

    unsigned short number_DataOutFuncs;
    std::vector<BaseDataIn*> DataOut;

    //Funktionen
    soundin(int BufferSizeIn,int SampleRateIn, short int fps);
    ~soundin();
    void AddSoundDataOut(BaseDataIn*);
    bool StartRecording();
    void StopRecording();
};

#endif

Soundin.cpp

#include <windows.h>
#include <stdio.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <vector>
#include "waveview.h"
#include "thengine.h"
#include "soundin.h"

extern renderer *render1;

DWORD WINAPI SoundInProc(LPVOID arg){
  MSG msg;
  float start,stop;
  short int *temp;
  unsigned short i,rest;
  soundin *klasse;
  FILE *debugtxt;
  WAVEHDR* data;
  while (GetMessage(&msg, 0, 0, 0) == 1)
  {
      switch(msg.message){
        case MM_WIM_DATA:
          data = (WAVEHDR*) msg.lParam;
          if(data){
            klasse = (soundin*) data->dwUser;
            if(klasse){
              if(klasse->number_DataOutFuncs > 0){
              klasse->CurrentDataBlock = render1->TimerGetTime();
              start = klasse->CurrentDataBlock;
              klasse->TimeDifference = klasse->CurrentDataBlock - klasse->LastDataBlock;
              //Daten aus der Struktur auslesen
              temp = new short int[klasse->BufferSize];
              for(i=0;i<data->dwBytesRecorded/2;i++){
                temp[i] = data->lpData[i];
              }
              if(klasse->recording){ //Do we need to add headers?
                //Header leeren und wieder anhängen
                /*data->dwBufferLength = klasse->BufferSize*2;
                data->dwBytesRecorded=0;
                data->dwUser = 0L;
                data->dwFlags = 0L;
                data->dwLoops = 0L;
                klasse->result = waveInPrepareHeader(klasse->InputDevice, data, sizeof(WAVEHDR));
                if (klasse->result)
                {
                  waveInGetErrorText(klasse->result, klasse->fault, 256);
                  debugtxt = fopen("debug.txt","a");
                  fprintf(debugtxt,"Error preparing Buffer on the run: %s\n",klasse->fault);
                  fprintf(debugtxt,"BufferLength=%i,BufferSize=%i\n",data->dwBufferLength,data->dwBytesRecorded);
                  fclose(debugtxt);
                }*/
                klasse->result = waveInAddBuffer(klasse->InputDevice, data, sizeof(WAVEHDR));
                if (klasse->result)
                {
                  waveInGetErrorText(klasse->result, klasse->fault, 256);
                  debugtxt = fopen("debug.txt","a");
                  fprintf(debugtxt,"Error Adding Buffer on the run: %s\n",klasse->fault);
                  fclose(debugtxt); 
                }
              }
              /*rest = data->dwBytesRecorded/2 - i;
              //restliche bytes null setzten
              for(i=rest;i<data->dwBytesRecorded/2;i++){
                temp[i] = 0;
              }*/  
              //allen erwähnten DataOut Funnktionen die Daten übergeben                    
              for(i=0;i<klasse->number_DataOutFuncs;i++){
                klasse->DataOut[i]->DataIn(temp);
              }
              //Speicher freigeben
              delete temp;
              stop = render1->TimerGetTime();
              debugtxt = fopen("debug.txt","a");
              fprintf(debugtxt,"Buffer 0x%X in %.2f\n",msg.lParam,stop-start);
              if(klasse->TimeDifference > klasse->DataBlockNormTime){
                fprintf(debugtxt,"Critical Time between Buffers(%X): %.4f\n",msg.lParam,klasse->TimeDifference);
                fclose(debugtxt);
              }
              klasse->LastDataBlock = klasse->CurrentDataBlock;
            }
          }       
        }
        continue;
        case MM_WIM_CLOSE:
		  /* Terminate this thread (by return'ing) */
		  break;
      }
  }
  return(0);    
}

soundin::soundin(int BufferSizeIn,int SampleRateIn, short int fps){
    HANDLE TempHandle;
    debugtxt = fopen("debug.txt","a");
    fprintf(debugtxt,"soundin(%i,%i,%i)\n",BufferSizeIn,SampleRateIn,fps);
    fclose(debugtxt);
    SampleRate = SampleRateIn;
    BufferSize = SampleRate / fps;
    DataBlockNormTime = 1000 / fps;
    format.wFormatTag=WAVE_FORMAT_PCM;     // simple, uncompressed format
    format.nChannels=1;                    //  1=mono, 2=stereo
    format.nSamplesPerSec=SampleRate;      // 44100
    format.nAvgBytesPerSec=SampleRate*2;   // = nSamplesPerSec * n.Channels * wBitsPerSample/8
    format.nBlockAlign=2;                  // = n.Channels * wBitsPerSample/8
    format.wBitsPerSample=16;              //  16 for high quality, 8 for telephone-grade
    format.cbSize=0;

    //Set Callbackfunc
    CallbackFunc = SoundInProc;

   	TempHandle = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)CallbackFunc, 0, 0, &CallbackThread);
	if (!TempHandle)
	{
		debugtxt = fopen("debug.txt","a");
        fprintf(debugtxt,"Can't create WAVE recording thread! -- %08X\n", GetLastError());
        fclose(debugtxt);
		init_done = false;
	}
	CloseHandle(TempHandle);

    //Create Our Buffers
    buffer1 = new short int[BufferSize];
    buffer2 = new short int[BufferSize];

    //Set Recording false
    recording = false;
    number_DataOutFuncs = 0;

    result = waveInOpen(&InputDevice, WAVE_MAPPER ,&format,
               (DWORD)CallbackThread, 0, CALLBACK_THREAD);

    if(result){
      waveInGetErrorText(result, fault, 256);
      debugtxt = fopen("debug.txt","a");
      fprintf(debugtxt,"Error Opening Sound In: %s\n",fault);
      fclose(debugtxt);
      init_done = false;
    }
    else
      init_done = true;
     // Set up and prepare first header for input
     WaveInHdr1.lpData = (LPSTR)buffer1;
     WaveInHdr1.dwBufferLength = BufferSize*2;
     WaveInHdr1.dwBytesRecorded=0;
     WaveInHdr1.dwUser = (DWORD)this;
     WaveInHdr1.dwFlags = 0L;
     WaveInHdr1.dwLoops = 0L;
     result = waveInPrepareHeader(InputDevice, &WaveInHdr1, sizeof(WAVEHDR));
     if (result)
     {
       waveInGetErrorText(result, fault, 256);
       debugtxt = fopen("debug.txt","a");
       fprintf(debugtxt,"Error preparing Buffer 1: %s\n",fault);
       fprintf(debugtxt,"BufferLength=%i,BufferSize=%i\n",WaveInHdr1.dwBufferLength,WaveInHdr1.dwBytesRecorded);
       fclose(debugtxt);
       recording=false;
       init_done=false; 
     }

     // Set up and prepare second header for input
     WaveInHdr2.lpData = (LPSTR)buffer2;
     WaveInHdr2.dwBufferLength = BufferSize*2;
     WaveInHdr2.dwBytesRecorded=0;
     WaveInHdr2.dwUser = (DWORD)this;
     WaveInHdr2.dwFlags = 0L;
     WaveInHdr2.dwLoops = 0L;
     result = waveInPrepareHeader(InputDevice, &WaveInHdr2, sizeof(WAVEHDR));
     if (result)
     {
       waveInGetErrorText(result, fault, 256);
       debugtxt = fopen("debug.txt","a");
       fprintf(debugtxt,"Error preparing Buffer 1: %s\n",fault);
       fclose(debugtxt);
       recording=false;
       init_done = false; 
     }
}

soundin::~soundin(){
    if(recording && init_done){
      recording=false;
      result = waveInReset(InputDevice);
      if(result){
        waveInGetErrorText(result, fault, 256);
        debugtxt = fopen("debug.txt","a");
        fprintf(debugtxt,"Error resetting SoundIn: %s\n",fault);
        fclose(debugtxt);
        init_done = false;
      }
    }
    if(init_done){
      Sleep(100);
      waveInUnprepareHeader(InputDevice, &WaveInHdr1, sizeof(WAVEHDR));
      waveInUnprepareHeader(InputDevice, &WaveInHdr2, sizeof(WAVEHDR));
      result = waveInClose(InputDevice);
      if(result){
        waveInGetErrorText(result, fault, 256);
        debugtxt = fopen("debug.txt","a");
        fprintf(debugtxt,"Error closing SoundIn: %s\n",fault);
        fclose(debugtxt);
        init_done = false;
      }
    }

    delete buffer1;
    delete buffer2;
}

bool soundin::StartRecording(){
    if(init_done && !recording){
     recording = true;
     LastDataBlock=render1->TimerGetTime();

     // Insert Buffers
     //Buffer 1
     result = waveInAddBuffer(InputDevice, &WaveInHdr1, sizeof(WAVEHDR));
     if (result)
     {
       waveInGetErrorText(result, fault, 256);
       debugtxt = fopen("debug.txt","a");
       fprintf(debugtxt,"Error Adding Buffer 1: %s\n",fault);
       fclose(debugtxt);
       recording=false;
       return false; 
     }

     //Buffer 2
     result = waveInAddBuffer(InputDevice, &WaveInHdr2, sizeof(WAVEHDR));
     if (result)
     {
       waveInGetErrorText(result, fault, 256);
       debugtxt = fopen("debug.txt","a");
       fprintf(debugtxt,"Error Adding Buffer 2: %s\n",fault);
       fclose(debugtxt);
       recording=false;
       return false;
     }

     // Start Recording
     result = waveInStart(InputDevice);
     if (result)
     {
       waveInGetErrorText(result, fault, 256);
       debugtxt = fopen("debug.txt","a");
       fprintf(debugtxt,"Error Start Recording: %s\n",fault);
       fclose(debugtxt);
       recording=false;
       return false;
     }
     return true;
    }
    else
      return false;
}

void soundin::StopRecording(){
    if(recording && init_done){
      recording = false;
      result = waveInReset(InputDevice);
      if(result){
        waveInGetErrorText(result, fault, 256);
        debugtxt = fopen("debug.txt","a");
        fprintf(debugtxt,"Error resetting SoundIn: %s\n",fault);
        fclose(debugtxt);
        init_done = false;
      }
    }
}

void soundin::AddSoundDataOut(BaseDataIn* klasse){
     number_DataOutFuncs++;
     DataOut.push_back(klasse);
}

Bei dieser Version ensteht ab und zu ein Fehler beim Herunterfahren des Programms, allerdings ist das nicht mein Problem.