sprint/audio/audio.h

/*==========================================================================;
 *
 *  Copyright (C) ©1994-1999 Paolo Medici Software.  All Rights Reserved.
 *
 *  File:   PmSound.h
 *  Content:    Common gate to DirectSound 6
 *
 ****************************************************************************/

#ifndef PM_SOUND
#define PM_SOUND

#include <mmsystem.h>
#include <dsound.h>
#include <dxcp.h>

#ifdef __cplusplus

// =========================== AREA C++ =======================

#define AUDIOSTREAMEVENTS 2

// Notify Overloading System
#define AN_PLAY         1
#define AN_STOP         2
#define AN_END          3       // Fine Canzone

// Controlla il volume
#define ASF_CTRLVOLUME  0x00000001
#define ASF_CTRLPAN             0x00000002
#define ASF_CTRLFREQ    0x00000004

// Deve Playare più di un file
#define ASF_MULTIPLE    0x00000100

class AudioStream {
private:
        LPDIRECTSOUNDNOTIFY         lpdsNotify;
        DSBPOSITIONNOTIFY           rgdsbpn[AUDIOSTREAMEVENTS];
        DWORD   dwFileStartPos;
protected:
        DWORD   dwFlags;
    LPDIRECTSOUNDBUFFER                 lpdsb;   
        UINT    cbDataSize;
        UINT    cbBufferSize;   // 2 secondi
        DWORD   dwStopNextTime;
        LONG    lVolume;
public:
    UINT        uCountDown;
    HANDLE      hfile;
    BOOL    m_bPlaying;                  // Whether sound is playing
        HANDLE  rghEvent[AUDIOSTREAMEVENTS];

    HRESULT CreateFromHandle();
    HRESULT CreateFromFile(LPCSTR lpszFile);
    VOID    SetOptions( LONG lFrequency, LONG lPan, LONG lVolume );
        // Il volume è in valore assoluto questa volta.
        // va da 0 (silence) a 10000 (max)
        VOID    SetVolume(LONG lVolume);
        VOID    SetPan(LONG lPan);
    HRESULT Play( BOOL bLooped = FALSE );
    HRESULT Stop();
        void Rewind();
        void Release();
    BOOL CheckForNotificationSignal();
        void HandleNotificationSignal();
        BOOL StreamToBuffer(DWORD dwPos);
        BOOL Init(DWORD dwFlag=0);
        void Done();

        // Overloading...
        virtual void Notify(DWORD);
};

class AudioThread {
protected:
        HANDLE hAudioThread;
        DWORD dwAudioThreadId;
        HANDLE CloseEvent;
        AudioStream *pas;
public:
        AudioThread();
        ~AudioThread();
        // Unused
        void Initialize();
        
        void HandleStream(AudioStream &as);

        void UnlinkStream(AudioStream &as);
        
        void CloseStream(BOOL bSelfRefreshing=TRUE);

        friend DWORD WINAPI AudioThreadFunc(AudioThread *);
};

// =========================== AREA C++ (fine) ==================

extern "C" {
#endif

#include <pshpack1.h>

#define PCM_ID  'xMCP'

// valori per wVersion

        // PCM_UNCOMPRESSED DATA:
#define PCM_VERSION             0x0101
        
#define FLAG_STEREO             0x0001  //
#define FLAG_HIBIT              0x0002  // 16 bit

        // i Dati che seguono l'header contengono il tag per il WAVEFORMATEX
        // dati da passare al ACM Converter in loading...
#define FLAG_WAVEFORMATEX       0x8000

typedef struct IDirectPCM {
        WORD wFlag;
        WORD wReserved;
        DWORD dwSize;
        // frequenza di campionamento
        DWORD dwFreq;    // supporto per frequenze sul 96KHz!!!!
} PCMHEAD, *LPPCMHEAD;

#include <poppack.h>

extern LPDIRECTSOUND               lpds;
extern DSBUFFERDESC                dsbdesc;
extern LPDIRECTSOUNDBUFFER         lpdsbPrimary;

extern BOOL InitDSoundEx(HWND hwnd, 
                                           GUID *pguid, 
                                           LPWAVEFORMATEX pwfx, 
                                           BOOL bForceSecondary);

extern BOOL InitDSound(HWND hwnd, 
                                           LPWAVEFORMATEX pwfx);

extern void CreateWaveEx(LPWAVEFORMATEX, DWORD, BOOL, BOOL);
extern void CreateWave(LPWAVEFORMATEX pwfx, LPPCMHEAD pcm);
extern void DSExit(void);

#define DSBCAPS_FASTPLAY        DSBCAPS_STATIC
#define DSBCAPS_STANDARD        (DSBCAPS_STATIC | DSBCAPS_CTRLVOLUME)
#define DSBCAPS_MODULATE        (DSBCAPS_STATIC | DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME)

// Crea un buffer sonoro da un file pcw
extern LPDIRECTSOUNDBUFFER CreateSoundBuffer(LPCSTR flnm,DWORD dwFlag);
extern LPDIRECTSOUNDBUFFER CreateSoundBufferFromHandle(HANDLE, DWORD dwFlag);

extern LPDIRECTSOUNDBUFFER CreateEmptySoundBuffer(LPPCMHEAD lpPcm, DWORD dwFlag);

extern LPDIRECTSOUNDBUFFER CreateFullSoundBuffer(LPPCMHEAD lpPcm, 
                                                                                                 LPVOID lpData, DWORD dwFlag);

HRESULT WaitStopSound(LPDIRECTSOUNDBUFFER lpdsb);

// I pack di strumenti sono normali pack
UINT LoadSoundPack(LPCSTR lpszFilename, 
                                   LPDIRECTSOUNDBUFFER *lpdsbList, 
                                   UINT lSize, 
                                   DWORD dwFlag);

// ==================== PMMODULE =================================

typedef struct _MODULEDESC           FAR *LPMODULEDESC;

typedef struct _MODULEDESC {
        DWORD                           dwSize;
        char                            name[64];
        DWORD                           dwType;
        DWORD                           dwStatus;
        DWORD                           dwCaps;

        DWORD                           dwOrders;
        DWORD                           dwPatterns;
        DWORD                           dwInstruments;
        DWORD                           dwSamples;
        DWORD                           dwChannels;
} MODULEDESC;


typedef struct _MODULESTATUS           FAR *LPMODULESTATUS;

typedef struct _MODULESTATUS {
        DWORD                           dwSize;

        DWORD                           dwStatus;
        DWORD                           dwTime;
        
        DWORD                           dwOrder;
        DWORD                           dwPattern;
        DWORD                           dwSpeed;
        DWORD                           dwBPM;
        DWORD                           dwRow;


} MODULESTATUS;

struct IMusicModule;

typedef struct IMusicModule              FAR *LPMUSICMODULE;

#if defined( _WIN32 ) && !defined( _NO_COM )
#undef INTERFACE
#define INTERFACE IMusicModule
DECLARE_INTERFACE( IMusicModule)
{
    /*** IUnknown0 methods **/
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
    STDMETHOD_(ULONG,Release) (THIS) PURE;
    /*** IMusicModule methods ***/
        STDMETHOD(GetCaps)(THIS_ LPMODULEDESC) PURE;
        STDMETHOD(GetStatus)(THIS_ LPMODULESTATUS) PURE;
        STDMETHOD(Play)(THIS) PURE;
        STDMETHOD(SetPosition)(THIS_ DWORD) PURE;
        STDMETHOD(GetPosition)(THIS_ LPDWORD) PURE;
        STDMETHOD(Stop)(THIS) PURE;
        STDMETHOD(NotifyStatus)(THIS) PURE;

        STDMETHOD(SetPanSeperation)(THIS_ FLOAT) PURE;

        STDMETHOD(GetSample)(THIS_ DWORD sampno, LPVOID) PURE;
};
#endif

struct IPMMusic;

typedef struct IPMMusic              FAR *LPPMMUSIC;

#if defined( _WIN32 ) && !defined( _NO_COM )
#undef INTERFACE
#define INTERFACE IPMMusic
DECLARE_INTERFACE( IPMMusic)
{
    /*** IUnknown0 methods **/
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
    STDMETHOD_(ULONG,Release) (THIS) PURE;
    /*** IPMMusic methods ***/
        STDMETHOD(SetInterface)(THIS_ LPDIRECTSOUND lpdds) PURE;
        STDMETHOD(GetCaps)(THIS) PURE;
        STDMETHOD(EnumMixer)(THIS) PURE;
        STDMETHOD(SetMixer)(THIS_ DWORD) PURE;
        STDMETHOD(GetMixer)(THIS_ DWORD) PURE;
        STDMETHOD(StopAllSong) (THIS) PURE;

        STDMETHOD(LoadSong)(THIS_ LPCSTR lpszFile, LPMUSICMODULE FAR *ppModule) PURE;
        STDMETHOD(LoadSongMemory)(THIS_ LPVOID lpData, DWORD dwSize, LPMUSICMODULE FAR *ppModule) PURE;
};
#endif

// ==================== MGR ======================================
extern BOOL WritePCMFile(LPCSTR file, LPPCMHEAD lpPcm, LPBYTE src);

extern DWORD WritePCMFileEx(HANDLE hfile, LPPCMHEAD lpPcm, LPBYTE src);

extern BOOL WriteSoundModule(LPCSTR lpszFilename, LPVOID lpDst);

// ==================== GESTIONE FILE WAVE ====================
void CreatePCMHeader(LPPCMHEAD lpPcmDst, LPPCMWAVEFORMAT lpPcmSrc);
void AcquireWaveHeader(LPCSTR file, PCMHEAD *ppcm);
LPBYTE ReadWaveFile(LPCSTR file, PCMHEAD *ppcm);

// ==================== SPECIAL FX ===========================

typedef struct IndirectFadeParam{
        LPDIRECTSOUNDBUFFER lpdsb;
        UINT fadetime;
} FADEPARAM, *LPFADEPARAM;

HANDLE museFadeOut(LPDIRECTSOUNDBUFFER lpdsb, UINT fadetime);
HANDLE museFadeIn(LPDIRECTSOUNDBUFFER lpdsb, UINT fadetime);

typedef int (FAR WINAPI * LPWAKEUPPROC) (LPARAM);

BOOL museWakeUpProc(HANDLE hEvent, LPWAKEUPPROC lpProc, LPARAM lparam);

DWORD WINAPI AudioFadeOut(LPFADEPARAM p);
DWORD WINAPI AudioFadeIn(LPFADEPARAM p);

// ==================== DSOUND EMULAZIONE ======================

// E' possibile creare un DirectSound completamente via software
// per usare o il WaveOut, o il PCSpeaker, o Dummy,
// che non fà niente...

#define DSCLASS_DUMMY           0
#define DSCLASS_WAVEEMUL        1
#define DSCLASS_PCSPEACKER      2

HRESULT WINAPI EmulDirectSoundCreate(DWORD dwClass, 
                                                                         LPDIRECTSOUND * ppDS);

extern GUID CLSID_EmulDirectSound;

#ifdef __cplusplus
}
#endif

#endif

// #pragma comment(lib, "dsound.lib")