summaryrefslogtreecommitdiffhomepage
path: root/Stars45/SoundD3D.h
blob: a667182d5ab199aae6c920e9a1ff4e907a3d9b5c (plain)
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
    Copyright (c) 1997-2006, Destroyer Studios LLC.

    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    DirectSound3D Audio Output and Buffer classes
*/

#ifndef SoundD3D_h
#define SoundD3D_h

#include <mutex>

//#define DIRECT_SOUND_3D
#include "SoundCard.h"
#include "Sound.h"
#include "Camera.h"
#include <stdio.h>
#include <dsound.h>
#include "vorbis/vorbisfile.h"

// +--------------------------------------------------------------------+

class SoundD3D;
class SoundCardD3D;

// +--------------------------------------------------------------------+
// Sound Implementation for DirectSound and DirectSound3D

class SoundD3D : public Sound
{
public:
    static const char* TYPENAME() { return "SoundD3D"; }

    SoundD3D(LPDIRECTSOUND card, DWORD flags, LPWAVEFORMATEX format);
    SoundD3D(LPDIRECTSOUND card, DWORD flags, LPWAVEFORMATEX format, DWORD len, LPBYTE data);
    virtual ~SoundD3D();

    virtual void      Update();

    virtual HRESULT   StreamFile(const char* name, DWORD offset);
    virtual HRESULT   Load(DWORD bytes, BYTE* data);
    virtual HRESULT   Play();
    virtual HRESULT   Rewind();
    virtual HRESULT   Pause();
    virtual HRESULT   Stop();

    virtual Sound*    Duplicate();

    // (only for streamed sounds)
    virtual double    GetTotalTime()     const   { return total_time; }
    virtual double    GetTimeRemaining() const;
    virtual double    GetTimeElapsed()   const;

    // (only used for localized sounds)
    virtual void      SetVolume(long v);
    virtual long      GetPan() const;
    virtual void      SetPan(long p);
    virtual void      SetLocation(const Vec3& l);
    virtual void      SetVelocity(const Vec3& v);

    virtual float     GetMinDistance() const;
    virtual void      SetMinDistance(float f);
    virtual float     GetMaxDistance() const;
    virtual void      SetMaxDistance(float f);


protected:
    void      Localize();
    HRESULT   AllocateBuffer(DWORD bytes);
    HRESULT   StreamOggFile();

    void      StreamBlock();
    void      StreamOggBlock();
    void      RewindStream();
    void      RewindOggStream();

    LPDIRECTSOUND              soundcard;
    WAVEFORMATEX               wfex;
    DSBUFFERDESC               dsbd;
    LPDIRECTSOUNDBUFFER        buffer;

    DWORD                      data_len;
    LPBYTE                     data;

#ifdef DIRECT_SOUND_3D
    LPDIRECTSOUND3DBUFFER      sound3d;
#endif

    float                      min_dist;
    float                      max_dist;

    // STREAMED SOUND SUPPORT:
    FILE*             stream;
    DWORD             stream_left;
    double            total_time;
    DWORD             min_safety;
    DWORD             read_size;
    BYTE*             transfer;
    DWORD             w, r;
    DWORD             stream_offset;
    bool              eos_written;
    BYTE              eos_latch;
    bool              moved;

    std::mutex        sync;
    OggVorbis_File*   ov_file;
};

// +--------------------------------------------------------------------+
// Sound Card Implementation for DS and DS3D

class SoundCardD3D : public SoundCard
{
    friend class SoundD3D;

public:
    static const char* TYPENAME() { return "SoundCardD3D"; }

    SoundCardD3D(HWND hwnd);
    virtual ~SoundCardD3D();

    // Format of the sound card's primary buffer:
    virtual bool   GetFormat(LPWAVEFORMATEX format);
    virtual bool   SetFormat(LPWAVEFORMATEX format);
    virtual bool   SetFormat(int bits, int channels, int hertz);

    virtual void   ShowFormat();

    // Get a blank, writable sound buffer:
    virtual Sound* CreateSound(DWORD flags, LPWAVEFORMATEX format);

    // Create a sound resource:
    virtual Sound* CreateSound(DWORD flags, LPWAVEFORMATEX format, DWORD len, LPBYTE data);

    virtual void   SetListener(const Camera& cam, const Vec3& vel);
    virtual bool   Pause();
    virtual bool   Resume();
    virtual bool   StopSoundEffects();

protected:
    LPDIRECTSOUND              soundcard;
    LPDIRECTSOUNDBUFFER        primary;

#ifdef DIRECT_SOUND_3D
    LPDIRECTSOUND3DLISTENER    listener;
#else
    Camera                     listener;
    Vec3                       velocity;
#endif

    WAVEFORMATEX               wfex;
    DSBUFFERDESC               dsbd;
};

#endif  // SoundD3D_h