Audio Player Thread

Being fed up with Windows Media Player lagging and screwing up my playlist I decided to pursue my own audio player. I used the Windows WaveOut API and made a thread that would control the position while the main thread set it's play/stop/restart flags, and it loads the entire file into memory removing the need for a file handle. It works, but the audio sounds a bit choppy and plays slower than on other players, and I don't understand why. Here's the code for the player:

Code:

---

#include <windows.h>
#include <stdbool.h>
#define MAXBUFFSIZE 44100
#define WM_PLYBCKERR (WM_USER+1)
#define WM_ENDPLAY (WM_USER+2)
#define FLAG_RTHR 0x00000001
#define FLAG_STHR 0xFFFFFFFE
#define FLAG_PLAY 0x00000002
#define FLAG_STOP 0xFFFFFFFD
#define FLAG_REST 0x00000004
#define FLAG_STAR 0xFFFFFFFB
#define FLAG_DONE 0x00000008
#define FLAG_NDON 0xFFFFFFF7
/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
typedef struct _wave_struct {
      WAVEFORMATEX wsFormat;
      PBYTE FileData;
      LPWAVEHDR Hdrs;
      unsigned int HdrC;
} WAVE_STRUCT, *PWAVE_STRUCT;
typedef struct _wave_file_hdr {
      char wfhSign[4];
      unsigned int wfhChnkSize;
      char wfhFormat[4];
      char wfhSubChnk1ID[4];
      unsigned int wfhSubChnk1Size;
      unsigned short wfhAudFormat;
      unsigned short wfhChannels;
      unsigned int wfhSampPerSec;
      unsigned int wfhAvgBytesPerSec;
      unsigned short wfhBlockAlign;
      unsigned short wfhBitsPerSamp;
      char wfhSubChnk2Sign[4];
      unsigned int wfhSubChnk2Size;
} WAVE_FILE_HDR, *PWAVE_FILE_HDR;
typedef HANDLE THREAD;
typedef struct _thr_data {
      THREAD Thr;
      WAVE_STRUCT ws;
      HWAVEOUT wOut;
      unsigned int Flags;
      char *wLoc;
      HWND hwndPar;
      ULONG ID;
} THREAD_DATA, *PTHREAD_DATA;
CRITICAL_SECTION wCrit;
bool LoadWaveFile(PWAVE_STRUCT ws,char *Loc){
      if(!ws||!Loc){
            SetLastError(ERROR_INVALID_PARAMETER);
            return false;
      }
      WAVE_FILE_HDR Head = {{0,0,0,0},0,{0,0,0,0},{0,0,0,0},0,0,0,0,0,0,0,{0,0,0,0},0};
      DWORD Read = 0, i = 0;
      PBYTE wPoint = 0;
      HANDLE wFile = CreateFile(Loc,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);
      if(wFile==INVALID_HANDLE_VALUE) return false;
      if(!ReadFile(wFile,&Head,sizeof(Head),&Read,NULL)){
            CloseHandle(wFile);
            return false;
      }
      if(Head.wfhSign[0] != 'R' || Head.wfhSign[1] != 'I' || Head.wfhSign[2] != 'F' || Head.wfhSign[3] != 'F'){
            SetLastError(ERROR_NOT_SUPPORTED);
            CloseHandle(wFile);
            return false;
      }
      if(Head.wfhFormat[0] != 'W' || Head.wfhFormat[1] != 'A' || Head.wfhFormat[2] != 'V' || Head.wfhFormat[3] != 'E'){
            CloseHandle(wFile);
            SetLastError(ERROR_NOT_SUPPORTED);
            return false;
      }
      if(Head.wfhAudFormat!=WAVE_FORMAT_PCM){
            CloseHandle(wFile);
            SetLastError(ERROR_NOT_SUPPORTED);
            return false;
      }
      Read = 1 + (Head.wfhChnkSize-36) / MAXBUFFSIZE;
      ws->Hdrs = (WAVEHDR*)malloc(Read*sizeof(WAVEHDR)+(Head.wfhChnkSize-36));
      ZeroMemory(ws->Hdrs,Read*sizeof(WAVEHDR)+(Head.wfhChnkSize-36));
      if(!ws->Hdrs){
            CloseHandle(wFile);
            SetLastError(ERROR_OUTOFMEMORY);
            return false;
      }
      ws->FileData = (PBYTE)ws->Hdrs+Read*sizeof(WAVEHDR);
      ws->HdrC = Read;
      ReadFile(wFile,ws->FileData,Head.wfhChnkSize-36,&Read,NULL);
      if(Read!=(Head.wfhChnkSize-36)){
            free(ws->Hdrs);
            CloseHandle(wFile);
            free(ws->FileData);
            return false;
      }
      ws->wsFormat.wFormatTag = WAVE_FORMAT_PCM;
      ws->wsFormat.nChannels = Head.wfhChannels;
      ws->wsFormat.nSamplesPerSec = Head.wfhSampPerSec;
      ws->wsFormat.nAvgBytesPerSec = Head.wfhAvgBytesPerSec;
      ws->wsFormat.nBlockAlign = Head.wfhBlockAlign;
      ws->wsFormat.wBitsPerSample = Head.wfhBitsPerSamp;
      ws->wsFormat.cbSize = 0;
      CloseHandle(wFile);
      wPoint = ws->FileData;
      for(i=0;i<ws->HdrC-1;i++){
            ws->Hdrs[i].lpData = wPoint;
            ws->Hdrs[i].dwBufferLength = MAXBUFFSIZE;
            wPoint += MAXBUFFSIZE;
      }
      ws->Hdrs[ws->HdrC-1].lpData = wPoint;
      ws->Hdrs[ws->HdrC-1].dwBufferLength = (Head.wfhChnkSize-36) % MAXBUFFSIZE;
      SetLastError(ERROR_SUCCESS);
      return true;
}
void CALLBACK waveyProc(HWAVEOUT hwo,UINT uMsg,DWORD dwInstance,DWORD Param1,DWORD Param2){
      if(uMsg==WOM_DONE){
            unsigned int *Flags = (unsigned int*)dwInstance;
            EnterCriticalSection(&wCrit);
            *Flags |= FLAG_DONE;
            LeaveCriticalSection(&wCrit);
      }
      return;
}
ULONG WINAPI PlayThr(volatile PTHREAD_DATA pThrDat){
      MMRESULT mRes = MMSYSERR_NOERROR;
      unsigned int Pos = 0;
      if(!LoadWaveFile(&pThrDat->ws,pThrDat->wLoc)){
            PostMessage(pThrDat->hwndPar,WM_PLYBCKERR,0,GetLastError());
            ExitThread(0);
      }
      mRes = waveOutOpen(&pThrDat->wOut,WAVE_MAPPER,&pThrDat->ws.wsFormat,(DWORD_PTR)waveyProc,(DWORD_PTR)&pThrDat->Flags,CALLBACK_FUNCTION);
      if(mRes!=MMSYSERR_NOERROR){
            PostMessage(pThrDat->hwndPar,WM_PLYBCKERR,0,mRes);
            free(pThrDat->ws.Hdrs);
            ExitThread(0);
      }
      for(Pos=0;Pos<pThrDat->ws.HdrC;Pos++) waveOutPrepareHeader(pThrDat->wOut,&pThrDat->ws.Hdrs[Pos],sizeof(WAVEHDR));
      Pos = 0;
      waveOutWrite(pThrDat->wOut,&pThrDat->ws.Hdrs[Pos],sizeof(WAVEHDR));
      while(pThrDat->Flags & FLAG_RTHR){
            while(pThrDat->Flags & FLAG_PLAY){
                  if(pThrDat->Flags & FLAG_DONE){
                        Pos++;
                        if(Pos == pThrDat->ws.HdrC){
                              pThrDat->Flags &= FLAG_STOP;
                              Pos = 0;
                        }else{
                              waveOutWrite(pThrDat->wOut,&pThrDat->ws.Hdrs[Pos],sizeof(WAVEHDR));
                        }
                        pThrDat->Flags &= FLAG_NDON;
                  }
                  Sleep(10);
            }
            if(pThrDat->Flags & FLAG_REST){
                  Pos = 0;
                  pThrDat->Flags &= FLAG_STAR;
                  pThrDat->Flags |= FLAG_PLAY;
            }
            Sleep(250);
      }
      for(Pos=0;Pos<pThrDat->ws.HdrC;Pos++) waveOutUnprepareHeader(pThrDat->wOut,&pThrDat->ws.Hdrs[Pos],sizeof(WAVEHDR));
      free(pThrDat->ws.Hdrs);
      waveOutClose(pThrDat->wOut);
      PostMessage(pThrDat->hwndPar,WM_ENDPLAY,0,0);
      ExitThread(0);
}
char szClassName[ ] = "WavePlayer";
char err[512];
char *wLoc = NULL;
int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil){
    HWND hwnd;
    MSG messages;
    WNDCLASSEX wincl;
    if(!SLen(lpszArgument)){
          ErrorBox(NULL,"No sound file specified!");
          return 0;
    }else{
          wLoc = lpszArgument;
    }
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;
    wincl.style = CS_DBLCLKS;
    wincl.cbSize = sizeof(WNDCLASSEX);
    wincl.hIcon = LoadIcon (NULL,IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL,IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL,IDC_ARROW);
    wincl.lpszMenuName = NULL;
    wincl.cbClsExtra = 0;
    wincl.cbWndExtra = 0;
    wincl.hbrBackground = (HBRUSH)COLOR_BACKGROUND;
    if(!RegisterClassEx(&wincl)) return 0;
    hwnd = CreateWindowEx(
          0,
          szClassName,
          "Wavey",
          WS_OVERLAPPEDWINDOW|WS_VISIBLE,
          CW_USEDEFAULT,
          CW_USEDEFAULT,
          400,
          400,
          NULL,
          NULL,
          hThisInstance,
          NULL);
    while(GetMessage(&messages,NULL,0,0)){
          TranslateMessage(&messages);
          DispatchMessage(&messages);
    }
    return messages.wParam;
}
THREAD_DATA ThrData = {NULL,{{0,0,0,0,0,0,0},NULL,NULL,0},NULL,0,NULL};
/*  This function is called by the Windows function DispatchMessage()  */
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
    switch (message){
        case WM_CREATE: ;
            ThrData.hwndPar = hwnd;
            ThrData.wLoc = wLoc;
            ThrData.Flags = FLAG_PLAY|FLAG_RTHR;
            ThrData.Thr = CreateThread(NULL,1024,(LPTHREAD_START_ROUTINE)PlayThr,&ThrData,0,&ThrData.ID);
            if(!ThrData.Thr){
                  ErrorBox(hwnd,"Unable to initialize playback thread!");
                  PostQuitMessage(0);
            }
            InitializeCriticalSection(&wCrit);
            break;
        case WM_LBUTTONDOWN: ;
            if(ThrData.Thr){
                  if(ThrData.Flags & FLAG_PLAY){
                        ThrData.Flags &= FLAG_STOP;
                  }else{
                        ThrData.Flags |= FLAG_PLAY;
                  }
            }
            break;
        case WM_RBUTTONDOWN: ;
            if(ThrData.Thr){
                  if(ThrData.Flags & FLAG_PLAY){
                        ThrData.Flags &= FLAG_STOP;
                  }
                  ThrData.Flags |= FLAG_REST;
            }
            break;
        case WM_PLYBCKERR: ;
            sprintf(err,"Playback Error:\n(0x%X)",lParam);
            ErrorBox(hwnd,err);
            CloseHandle(ThrData.Thr);
            break;
        case WM_CLOSE: ;
            if(ThrData.Thr){
                  ThrData.Flags &= FLAG_STOP;
                  ThrData.Flags &= FLAG_STHR;
                  break;
            }
            PostQuitMessage(0);
            break;
        case WM_ENDPLAY: ;
            DestroyWindow(hwnd);
            CloseHandle(ThrData.Thr);
            break;
        case WM_DESTROY: ;
            DeleteCriticalSection(&wCrit);
            PostQuitMessage(0);
            break;
        default: ;
            return DefWindowProc (hwnd, message, wParam, lParam);
    }
    return ERROR_SUCCESS;
}

---

I'ts only supposed to play .wav files passed in the command line, and I'm compiling this program on Windows using the Bloodshed DevC++ IDE. I based this off an example from Playing Audio in Windows using waveOut Interface by David Overton - Translated by humans. I'd rather not use DirectShow or audio libraries for my program though. Any help would be appriciated.

maybe it is something to do with the priority it is running at?

I changed the priority of the process with task manager to different priorities, including Realtime but nothing changed. Still choppy.

Lane... take a look at MCI ... The windows prefab multimedia api. It provides playback for just about any file type windows can handle through codecs.

However, from what you're describing the problem may not be WMP or your code at all. It sounds like you have something that's not multitasking well, causing the sound card buffer to run dry... (It's actually a common problem, worse in Win7)

Visit my website ( HTPC Remote Control: Remote Media ) in the extras section you will find the DPC Latency tool... run it and see if anything is causing spikes. If you are getting spikes, drop me a note through my feedback link and we can try to sort it out via email.

Also... you should download and try Media Player Classic Home Cinema, also linked on my site. I've seen in play files in situations where no other player could.

I downloaded the DPC Latency Checker and apparently there is a problem with my sound card, there are spikes and the program evens says that some drivers are causing drop-outs. You were right, my sound cards the problem, probably because my netbook runs Windows 7 Starter.

Quote:

---

Originally Posted by Lane the Great

I downloaded the DPC Latency Checker and apparently there is a problem with my sound card, there are spikes and the program evens says that some drivers are causing drop-outs. You were right, my sound cards the problem, probably because my netbook runs Windows 7 Starter.

---

As I explained in the email... it's most likely to be something other than your sound card. It's process of elimination time but my money is on anti-virus software. As I mentioned, Norton is particularly bad for this...

Now... about using MCI instead of waveout... :D

To all reading this thread the sound card wasn't the problem with my program. I still can't find the cause of the slower playback and chopiness. Any one have an idea?

Diagnose your system using WMP and DPC-latency-checker. The code that's been posted has plenty of issues on its own.

Busy looping while calling Sleep() is never the way to implement a thread loop, and there's unsynchronized access to shared variables (ThrData). Both of these can be fixed by converting bit flags to Win32 events and use a WaitForMultipleObjects thead loop.

>> ULONG WINAPI PlayThr(volatile PTHREAD_DATA pThrDat)
This is an incorrect signature for a thread function. Calls to CreateThread should never cast the 3rd parameter. The "volatile" keyword has nothing to multi-threaded coding. (MSVC added their own extensions to the keyword, which no one should use, but you're not using a MS compiler.) Always use proper synchronization primitives provided by your OS/threading library.

gg

Quote:

---

Originally Posted by Lane the Great

To all reading this thread the sound card wasn't the problem with my program. I still can't find the cause of the slower playback and chopiness. Any one have an idea?

---

Per your email... your wireless adaptor is the hardware problem causing the choppiness in WMP... You need to follow the directions in my email and get that fixed before you do much else because, without that fixed, you won't know if it's the adaptor or your code that's causing the problems.

I see codeplug has had a look at your code... once you get WMP working correctly, you should work with him to sort out the code. He's clearly on the right track.

I installed the latest drive for my network adapter and also Driver Genius which scans for outdated drivers. It says my audio driver isn't up to date. I'll try and update that to see if it helps.

Quote:

---

Originally Posted by Lane the Great

I installed the latest drive for my network adapter and also Driver Genius which scans for outdated drivers. It says my audio driver isn't up to date. I'll try and update that to see if it helps.

---

Good idea... But a little hint first... Don't use the drivers from Microsoft update. Most of them are incomplete or limited. Go directly to the manufacturer's websites, that's usually where you get the best versions.

I updated the driver for my audio controller but it didn't help. I think my problem is with the synchronization of my threads like Codeplug said. The example mine's based off used Critical Sections to synchronize it's threads shared variables. I'm not too good with Waitable Timers and have only used them in OpenGL programs. How would I go about using WaitForMultipleObjects? or should it use WaitForSingleObject?

Quote:

---

Originally Posted by Lane the Great

I updated the driver for my audio controller but it didn't help.

---

Ok... as I said, you need to get WMP to play correctly before proceeding.
Do you still have latency spikes?

Latency Checker still spikes but only when my adapter is trying to connect to a wireless connection and Windows Media Player now plays with no problems. Finally!

Ok, that's good... keep an eye on the latency...

If you have Norton installed on that system you may want to remove it. It also causes these kinds of problems. Go with Windows Defender which is much better.

Now I'll step aside and let codeplug help you with the software...

Here are the flags converted to events and better window message handling (and a run through my code beautifier). Still needs proper error checking/handling. See if this still skips:

Code:

---

/* gcc main.c -lwinmm -std=c99 -pedantic */
#include <windows.h>
#include <stdbool.h>
#include <stdio.h>

#define MAXBUFFSIZE 44100
#define WM_PLYBCKERR (WM_USER+1)
#define WM_ENDPLAY (WM_USER+2)

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

void ErrorBox(HWND hwnd, const char *msg)
{
    MessageBox(hwnd, msg, "Error", MB_OK | MB_ICONSTOP);
}

typedef struct _wave_struct
{
    WAVEFORMATEX wsFormat;
    PBYTE FileData;
    LPWAVEHDR Hdrs;
    unsigned int HdrC;
} WAVE_STRUCT, *PWAVE_STRUCT;

typedef struct _wave_file_hdr
{
    char wfhSign[4];
    unsigned int wfhChnkSize;
    char wfhFormat[4];
    char wfhSubChnk1ID[4];
    unsigned int wfhSubChnk1Size;
    unsigned short wfhAudFormat;
    unsigned short wfhChannels;
    unsigned int wfhSampPerSec;
    unsigned int wfhAvgBytesPerSec;
    unsigned short wfhBlockAlign;
    unsigned short wfhBitsPerSamp;
    char wfhSubChnk2Sign[4];
    unsigned int wfhSubChnk2Size;
} WAVE_FILE_HDR, *PWAVE_FILE_HDR;

typedef enum
{
    PlayState_Exit,
    PlayState_Pause,
    PlayState_Play,
    PlayState_RewindPlay,
} PlayState;

typedef struct _thr_data
{
    HANDLE Thr;
    WAVE_STRUCT ws;
    HWAVEOUT wOut;
    char *wLoc;
    HWND hwndPar;
    ULONG ID;
    PlayState ps;
    CRITICAL_SECTION csps;
    HANDLE evPlayStateChange,
          evData;
} THREAD_DATA, *PTHREAD_DATA;

bool LoadWaveFile(PWAVE_STRUCT ws, const char *Loc)
{
    if (!ws || !Loc)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return false;
    }
    WAVE_FILE_HDR Head = {0};
    DWORD Read = 0, i = 0;
    PBYTE wPoint = 0;
    HANDLE wFile = CreateFile(Loc, GENERIC_READ, FILE_SHARE_READ,
                              NULL, OPEN_EXISTING, 0, NULL);
    if (wFile == INVALID_HANDLE_VALUE)
        return false;
   
    if (!ReadFile(wFile, &Head, sizeof(Head), &Read, NULL))
    {
        CloseHandle(wFile);
        return false;
    }

    if (Head.wfhSign[0] != 'R' || Head.wfhSign[1] != 'I' ||
        Head.wfhSign[2] != 'F' || Head.wfhSign[3] != 'F')
    {
        CloseHandle(wFile);
        SetLastError(ERROR_NOT_SUPPORTED);
        return false;
    }

    if (Head.wfhFormat[0] != 'W' || Head.wfhFormat[1] != 'A' ||
        Head.wfhFormat[2] != 'V' || Head.wfhFormat[3] != 'E')
    {
        CloseHandle(wFile);
        SetLastError(ERROR_NOT_SUPPORTED);
        return false;
    }

    if (Head.wfhAudFormat != WAVE_FORMAT_PCM)
    {
        CloseHandle(wFile);
        SetLastError(ERROR_NOT_SUPPORTED);
        return false;
    }

    Read = 1 + (Head.wfhChnkSize-36) / MAXBUFFSIZE;
    ws->Hdrs = (WAVEHDR*)malloc(Read * sizeof(WAVEHDR) +
                                (Head.wfhChnkSize - 36));
    if (!ws->Hdrs)
    {
        CloseHandle(wFile);
        SetLastError(ERROR_OUTOFMEMORY);
        return false;
    }
    ZeroMemory(ws->Hdrs, Read * sizeof(WAVEHDR) + (Head.wfhChnkSize - 36));

    ws->FileData = (PBYTE)ws->Hdrs+Read*sizeof(WAVEHDR);
    ws->HdrC = Read;
    ReadFile(wFile, ws->FileData, Head.wfhChnkSize - 36, &Read, NULL);
    if (Read != (Head.wfhChnkSize - 36))
    {
        free(ws->Hdrs);
        CloseHandle(wFile);
        free(ws->FileData);
        return false;
    }
    ws->wsFormat.wFormatTag = WAVE_FORMAT_PCM;
    ws->wsFormat.nChannels = Head.wfhChannels;
    ws->wsFormat.nSamplesPerSec = Head.wfhSampPerSec;
    ws->wsFormat.nAvgBytesPerSec = Head.wfhAvgBytesPerSec;
    ws->wsFormat.nBlockAlign = Head.wfhBlockAlign;
    ws->wsFormat.wBitsPerSample = Head.wfhBitsPerSamp;
    ws->wsFormat.cbSize = 0;
    CloseHandle(wFile);
    wPoint = ws->FileData;
    for (i = 0; i < ws->HdrC - 1; ++i)
    {
        ws->Hdrs[i].lpData = (LPSTR)wPoint;
        ws->Hdrs[i].dwBufferLength = MAXBUFFSIZE;
        wPoint += MAXBUFFSIZE;
    }
    ws->Hdrs[ws->HdrC-1].lpData = (LPSTR)wPoint;
    ws->Hdrs[ws->HdrC-1].dwBufferLength = (Head.wfhChnkSize-36) % MAXBUFFSIZE;
    SetLastError(ERROR_SUCCESS);
    return true;
}

void CALLBACK waveyProc(HWAVEOUT hwo, UINT uMsg, DWORD dwInstance,
                        DWORD Param1, DWORD Param2)
{
    if (uMsg == WOM_DONE)
    {
        PTHREAD_DATA pThrDat = (PTHREAD_DATA)dwInstance;
        SetEvent(pThrDat->evData);
    }
    return;
}

DWORD WINAPI PlayThr(void *param)
{
    PTHREAD_DATA pThrDat = (PTHREAD_DATA)param;
    MMRESULT mRes = MMSYSERR_NOERROR;
    unsigned int Pos = 0;
    bool bPaused = false;

    if (!LoadWaveFile(&pThrDat->ws, pThrDat->wLoc))
    {
        PostMessage(pThrDat->hwndPar, WM_PLYBCKERR, 0, GetLastError());
        return 0;
    }

    mRes = waveOutOpen(&pThrDat->wOut, WAVE_MAPPER, &pThrDat->ws.wsFormat,
                      (DWORD_PTR)waveyProc, (DWORD_PTR)pThrDat,
                      CALLBACK_FUNCTION);
    if (mRes != MMSYSERR_NOERROR)
    {
        PostMessage(pThrDat->hwndPar, WM_PLYBCKERR, 0, mRes);
        free(pThrDat->ws.Hdrs);
        return 0;
    }

    for (Pos = 0; Pos < pThrDat->ws.HdrC; ++Pos)
        waveOutPrepareHeader(pThrDat->wOut,
                            &pThrDat->ws.Hdrs[Pos],
                            sizeof(WAVEHDR));
   
#  define numWaitObjects 2
    const HANDLE waitObjects[numWaitObjects] =
    {
        pThrDat->evPlayStateChange,
        pThrDat->evData,
    };

    enum
    {
        WO_PLAYSTATE_CHANGE = WAIT_OBJECT_0 + 0,
        WO_MORE_DATA        = WAIT_OBJECT_0 + 1,
    };
   
    Pos = 0;
    SetEvent(pThrDat->evData);

    for (;;)
    {
        DWORD status = WaitForMultipleObjects(numWaitObjects, waitObjects,
                                              FALSE, INFINITE);
        if (status == WO_MORE_DATA)
        {
            if (!bPaused && Pos < pThrDat->ws.HdrC)
            {
                waveOutWrite(pThrDat->wOut,
                            &pThrDat->ws.Hdrs[Pos],
                            sizeof(WAVEHDR));
                ++Pos;
            }
        }
        else if (status == WO_PLAYSTATE_CHANGE)
        {
            PlayState nextState;
            EnterCriticalSection(&pThrDat->csps);
            nextState = pThrDat->ps;
            LeaveCriticalSection(&pThrDat->csps);

            if (nextState == PlayState_Exit)
            {
                break;
            }
            else if (nextState == PlayState_Pause)
            {
                bPaused = true;
                waveOutPause(pThrDat->wOut);
            }
            else if (nextState == PlayState_Play ||
                    nextState == PlayState_RewindPlay)
            {
                if (bPaused)
                    waveOutRestart(pThrDat->wOut);
                bPaused = false;
                if (nextState == PlayState_RewindPlay)
                {
                    waveOutReset(pThrDat->wOut);
                    Pos = 0;
                    SetEvent(pThrDat->evData);
                }
            }
        }
    }

    for (Pos = 0; Pos < pThrDat->ws.HdrC; ++Pos)
        waveOutUnprepareHeader(pThrDat->wOut,
                              &pThrDat->ws.Hdrs[Pos],
                              sizeof(WAVEHDR));
    waveOutClose(pThrDat->wOut);
    free(pThrDat->ws.Hdrs);
    PostMessage(pThrDat->hwndPar, WM_ENDPLAY, 0, 0);
    return 0;
}

THREAD_DATA ThrData = {0};
char szClassName[ ] = "WavePlayer";
char *wLoc = NULL;

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)
{
    HWND hwnd;
    MSG messages;
    WNDCLASSEX wincl;
    if (!lstrlen(lpszArgument))
    {
        ErrorBox(NULL,"No sound file specified!");
        return 0;
    }
    else
    {
        wLoc = lpszArgument;
    }
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;
    wincl.style = CS_DBLCLKS;
    wincl.cbSize = sizeof(WNDCLASSEX);
    wincl.hIcon = LoadIcon (NULL,IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL,IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL,IDC_ARROW);
    wincl.lpszMenuName = NULL;
    wincl.cbClsExtra = 0;
    wincl.cbWndExtra = 0;
    wincl.hbrBackground = (HBRUSH)COLOR_BACKGROUND;
    if (!RegisterClassEx(&wincl))
        return 0;
   
    hwnd = CreateWindowEx(0, szClassName, "Wavey",
                        WS_OVERLAPPEDWINDOW|WS_VISIBLE,
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        400, 400,
                        NULL, NULL, hThisInstance, NULL);
   
    while (GetMessage(&messages, NULL, 0, 0))
    {
        TranslateMessage(&messages);
        DispatchMessage(&messages);
    }

    return messages.wParam;
}

/*  This function is called by the Windows function DispatchMessage()  */
LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message,
                                WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
        ThrData.hwndPar = hwnd;
        ThrData.wLoc = wLoc;
        ThrData.ps = PlayState_Play;
        InitializeCriticalSection(&ThrData.csps);
        ThrData.evPlayStateChange = CreateEvent(0, FALSE, FALSE, 0);
        ThrData.evData = CreateEvent(0, FALSE, FALSE, 0);
        ThrData.Thr = CreateThread(NULL, 0, PlayThr, &ThrData, 0, &ThrData.ID);
        if (!ThrData.Thr)
        {
            ErrorBox(hwnd,"Unable to initialize playback thread!");
            PostQuitMessage(0);
        }
        break;

    case WM_LBUTTONDOWN:
        EnterCriticalSection(&ThrData.csps);
        if (ThrData.ps != PlayState_Pause)
            ThrData.ps = PlayState_Pause;
        else
            ThrData.ps = PlayState_Play;
        LeaveCriticalSection(&ThrData.csps);
        SetEvent(ThrData.evPlayStateChange);
        break;

    case WM_RBUTTONDOWN:
        EnterCriticalSection(&ThrData.csps);
        ThrData.ps = PlayState_RewindPlay;
        LeaveCriticalSection(&ThrData.csps);
        SetEvent(ThrData.evPlayStateChange);
        break;

    case WM_PLYBCKERR:
    {
        char err[512];
        sprintf(err, "Playback Error:\n(0x%X)", lParam);
        ErrorBox(hwnd, err);
        CloseHandle(ThrData.Thr);
        break;
    }

    case WM_ENDPLAY:
        CloseWindow(hwnd);
        break;

    case WM_DESTROY:
        EnterCriticalSection(&ThrData.csps);
        ThrData.ps = PlayState_Exit;
        LeaveCriticalSection(&ThrData.csps);
        SetEvent(ThrData.evPlayStateChange);
        WaitForSingleObject(ThrData.Thr, INFINITE);
        CloseHandle(ThrData.Thr);
        CloseHandle(ThrData.evData);
        CloseHandle(ThrData.evPlayStateChange);
        DeleteCriticalSection(&ThrData.csps);
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hwnd, message, wParam, lParam);
    }
    return ERROR_SUCCESS;
}

---

Wait Functions (Windows)
Event Objects (Windows)

gg

I tested and compiled the code. It didn't make any difference. the sound was still choppy. Here's the example code mine was based off that plays with no sound glitches:

Code:

---

#include <windows.h>
#include <mmsystem.h>
#include <stdio.h>
// some good values for block size and count
#define BLOCK_SIZE 8192
#define BLOCK_COUNT 5
// module level variables
CRITICAL_SECTION waveCriticalSection;
WAVEHDR* waveBlocks;
volatile int waveFreeBlockCount;
int waveCurrentBlock;
// function prototypes
void CALLBACK waveOutProc(HWAVEOUT hWaveOut,UINT uMsg,DWORD dwInstance,DWORD dwParam1,DWORD dwParam2){
      // pointer to free block counter
      int *freeBlockCounter = (int*)dwInstance;
      // ignore calls that occur due to openining and closing the device.
      if(uMsg!=WOM_DONE) return;
      EnterCriticalSection(&waveCriticalSection);
      (*freeBlockCounter)++;
      LeaveCriticalSection(&waveCriticalSection);
      return;
}
WAVEHDR* allocateBlocks(int size,int count){
      char *buffer;
      int i;
      WAVEHDR* blocks;
      DWORD totalBufferSize = (size+sizeof(WAVEHDR))*count;
      // allocate memory for the entire set in one go
      buffer = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,totalBufferSize);
      if(!buffer){
            printf("Memory allocation error\n");
            ExitProcess(0);
      }
      // and set up the pointers to each bit
      blocks = (WAVEHDR*)buffer;
      buffer += sizeof(WAVEHDR)*count;
      for(i=0;i<count;i++){
            blocks[i].dwBufferLength = size;
            blocks[i].lpData = buffer;
            buffer += size;
      }
      return blocks;
}
void freeBlocks(WAVEHDR* blockArray){
      // and this is why allocateBlocks works the way it does
      HeapFree(GetProcessHeap(),0,blockArray);
      return;
}
void writeAudio(HWAVEOUT hWaveOut,char *data,int size){
      WAVEHDR* current;
      int remain;
      current = &waveBlocks[waveCurrentBlock];
      while(size>0){
            // first make sure the header we're going to use is unprepared
            if(current->dwFlags & WHDR_PREPARED) waveOutUnprepareHeader(hWaveOut,current,sizeof(WAVEHDR));
            if(size < (int)(BLOCK_SIZE - current->dwUser)){
                  memcpy(current->lpData + current->dwUser,data,size);
                  current->dwUser += size;
                  break;
            }
            remain = BLOCK_SIZE-current->dwUser;
            memcpy(current->lpData+current->dwUser,data,remain);
            size -= remain;
            data += remain;
            current->dwBufferLength = BLOCK_SIZE;
            waveOutPrepareHeader(hWaveOut,current,sizeof(WAVEHDR));
            waveOutWrite(hWaveOut,current,sizeof(WAVEHDR));
            EnterCriticalSection(&waveCriticalSection);
            waveFreeBlockCount--;
            LeaveCriticalSection(&waveCriticalSection);
            // wait for a block to become free
            while(!waveFreeBlockCount) Sleep(10);
            // point to the next block
            waveCurrentBlock++;
            waveCurrentBlock %= BLOCK_COUNT;
            current = &waveBlocks[waveCurrentBlock];
            current->dwUser = 0;
      }
      return;
}
int main(int argc, char* argv[]){
      HWAVEOUT hWaveOut;  // device handle
      HANDLE hFile;      // file handle
      WAVEFORMATEX wfx;  // look this up in your documentation
      char buffer[1024]; // intermediate buffer for reading
      int i;
      //quick argument check
      if(argc != 2) {
            printf("usage: %s <filename>\n",argv[0]);
            return 0;
      }
      // initialise the module variables
      waveBlocks = allocateBlocks(BLOCK_SIZE, BLOCK_COUNT);
      waveFreeBlockCount = BLOCK_COUNT;
      waveCurrentBlock = 0;
      InitializeCriticalSection(&waveCriticalSection);
      // try and open the file
      hFile = CreateFile(argv[1],GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);
      if(hFile == INVALID_HANDLE_VALUE){
            printf("%s: unable to open file '%s'\n",argv[0],argv[1]);
            return 0;
      }
      // set up the WAVEFORMATEX structure.
      wfx.nSamplesPerSec = 44100; // sample rate
      wfx.wBitsPerSample = 16;    // sample size
      wfx.nChannels= 2;          // channel
      wfx.cbSize = 0;            // size of _extra_ info
      wfx.wFormatTag = WAVE_FORMAT_PCM;
      wfx.nBlockAlign = (wfx.wBitsPerSample * wfx.nChannels) >> 3;
      wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
/*
 * try to open the default wave device. WAVE_MAPPER is
 * a constant defined in mmsystem.h, it always points to the
 * default wave device on the system (some people have 2 or
 * more sound cards).
 */
      if(waveOutOpen(&hWaveOut,WAVE_MAPPER,&wfx,(DWORD_PTR)waveOutProc,(DWORD_PTR)&waveFreeBlockCount,CALLBACK_FUNCTION) != MMSYSERR_NOERROR){
            printf("%s: unable to open wave mapper device\n",argv[0]);
            return 0;
      }
      // playback loop
      while(1){
            DWORD readBytes;
            if(!ReadFile(hFile,buffer,sizeof(buffer),&readBytes,NULL)) break;
            if(!readBytes) break;
            if(readBytes < sizeof(buffer)){
                  printf("at end of buffer\n");
                  memset(buffer+readBytes,0,sizeof(buffer)-readBytes);
                  printf("after memcpy\n");
            }
            writeAudio(hWaveOut,buffer,sizeof(buffer));
      }
      // wait for all blocks to complete
      while(waveFreeBlockCount < BLOCK_COUNT) Sleep(10);
      // unprepare any blocks that are still prepared
      for(i=0;i<waveFreeBlockCount;i++) if(waveBlocks[i].dwFlags & WHDR_PREPARED) waveOutUnprepareHeader(hWaveOut,&waveBlocks[i],sizeof(WAVEHDR));
      DeleteCriticalSection(&waveCriticalSection);
      freeBlocks(waveBlocks);
      waveOutClose(hWaveOut);
      CloseHandle(hFile);
      return 0;
 }

---

This example is a console app. It works but our other codes' sound has drop-outs.

Ah - well they are trying to call waveOutWrite() multiple times in order to keep up to BLOCK_COUNT blocks queued up in the system. Your code and mine only kept one block queued.

Here is a modification to my version to achieve the same effect:

Code:

---

...

typedef struct _thr_data
{
    HANDLE Thr;
    WAVE_STRUCT ws;
    HWAVEOUT wOut;
    char *wLoc;
    HWND hwndPar;
    ULONG ID;
    PlayState ps;
    CRITICAL_SECTION csps;
    HANDLE evPlayStateChange,
          evData;
    LONG queuedBlocks;
} THREAD_DATA, *PTHREAD_DATA;

#define MAX_QUEUED_BLOCKS 5

...

void CALLBACK waveyProc(HWAVEOUT hwo, UINT uMsg, DWORD dwInstance,
                        DWORD Param1, DWORD Param2)
{
    if (uMsg == WOM_DONE)
    {
        PTHREAD_DATA pThrDat = (PTHREAD_DATA)dwInstance;
        InterlockedDecrement(&pThrDat->queuedBlocks);
        SetEvent(pThrDat->evData);
    }
    return;
}

...

DWORD WINAPI PlayThr(void *param)
{

...

        if (status == WO_MORE_DATA)
        {
            if (!bPaused)
            {
                LONG queuedBlocks = InterlockedExchangeAdd(&pThrDat->queuedBlocks, 0);
                while (Pos < pThrDat->ws.HdrC &&
                      queuedBlocks <= MAX_QUEUED_BLOCKS)
                {
                    waveOutWrite(pThrDat->wOut,
                                &pThrDat->ws.Hdrs[Pos],
                                sizeof(WAVEHDR));
                    ++Pos;
                    ++queuedBlocks;
                    InterlockedIncrement(&pThrDat->queuedBlocks);
                }
            }
        }

...

                if (nextState == PlayState_RewindPlay)
                {
                    waveOutReset(pThrDat->wOut);
                    Pos = 0;
                    InterlockedExchange(&pThrDat->queuedBlocks, 0);
                    SetEvent(pThrDat->evData);
                }
...

---

The Interlocked functions provide safe mult-threaded access without having to use a critical section. Modified source attached.

gg

You were right the code works. Thanks.