freedo/OutSound.cpp at master · MaxAkaAltmer/freedo · GitHub

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
// OutSound1.cpp: implementation of the COutSound class.
//
//////////////////////////////////////////////////////////////////////

#include "OutSound.h"

#ifndef NULL
#define NULL 0
#endif

#include "AL/al.h"
#include "AL/alc.h"

ALCdevice *pDevice;
ALCcontext *pContext;

#define BLOCK_SIZE  (1048)
#define BLOCK_COUNT 8
#define FREQ_VAL	44100

int FREQ_VAL_FREE=FREQ_VAL;

ALuint	sndalBuffs[BLOCK_COUNT], sndalSource;
unsigned int sndalQueue[BLOCK_SIZE], sndalCount;

bool SwapChannels=false;

void _sndal_SetVolume(float val)
{
	alSourcef (sndalSource, AL_GAIN,    val);
}
void _sndal_SetSpeed(float val)
{
	//alSourcef (sndalSource, AL_PITCH,    val);
        FREQ_VAL_FREE=FREQ_VAL*val;
}
void _sndal_SwapLR(bool val)
{
	SwapChannels=!val;
}

bool _sndal_Init()
{
 int i;

  // Ïîçèöèÿ ñëóøàòåëÿ.
  ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 };

  // Ñêîðîñòü ñëóøàòåëÿ.
  ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 };

  // Îðèåíòàöèÿ ñëóøàòåëÿ. (Ïåðâûå 3 ýëåìåíòà – íàïðàâëåíèå «íà», ïîñëåäíèå 3 – «ââåðõ»)
  ALfloat ListenerOri[] = { 0.0, 0.0, -1.0,  0.0, 1.0, 0.0 };

  ALfloat SourcePos[] = { 0, 0, 1 };

    // Îòêðûâàåì çàäàííîå ïî óìîë÷àíèþ óñòðîéñòâî
    pDevice = alcOpenDevice(NULL);
    // Ïðîâåðêà íà îøèáêè
    if (!pDevice)
    {
        return false;
    }
    // Ñîçäàåì êîíòåêñò ðåíäåðèíãà
    pContext = alcCreateContext(pDevice, NULL);
    if ( alcGetError(pDevice) != ALC_NO_ERROR) return false;

    // Äåëàåì êîíòåêñò òåêóùèì
    alcMakeContextCurrent(pContext);

    // Óñòàíàâëèâàåì ïàðàìåòðû ñëóøàòåëÿ
    // Ïîçèöèÿ
    alListenerfv(AL_POSITION,    ListenerPos);
    // Ñêîðîñòü
    alListenerfv(AL_VELOCITY,    ListenerVel);
    // Îðèåíòàöèÿ
    alListenerfv(AL_ORIENTATION, ListenerOri);

	sndalCount=0;
	alGenSources ( 1, &sndalSource );

	alSourcef (sndalSource, AL_PITCH,    1.0f);	//ñêîðîñòü
    alSourcef (sndalSource, AL_GAIN,    1.0f); //ãðîìêîñòü
    alSourcefv(sndalSource, AL_POSITION,  SourcePos);
    alSourcefv(sndalSource, AL_VELOCITY,  ListenerVel);
    alSourcei (sndalSource, AL_LOOPING,  false);

	alGenBuffers(BLOCK_COUNT, sndalBuffs);

	sndalQueue[0]=0;

	for(i=0;i<BLOCK_COUNT;i++)
	{
			alBufferData(sndalBuffs[i], AL_FORMAT_STEREO16, sndalQueue, 4, FREQ_VAL_FREE);
	}

	alSourceQueueBuffers(sndalSource, BLOCK_COUNT, sndalBuffs);

	alSourcePlay(sndalSource);

    return true;

}
static int      Processed = 0;
bool _sndal_Update(unsigned int RL)
{
 	if(sndalCount<(BLOCK_SIZE-1))
	{
                if(SwapChannels)RL=(RL>>16)|(RL<<16);
        	sndalQueue[sndalCount++]=RL;
		return true;
	}
	else
	{
                ALuint      BufID;

		Processed=0;
		alGetSourcei(sndalSource, AL_BUFFERS_PROCESSED, &Processed);
		if(!Processed)
		{
			return false;
		}

                if(SwapChannels)RL=(RL>>16)|(RL<<16);
		sndalQueue[sndalCount]=RL;

                sndalCount=0;
		alSourceUnqueueBuffers(sndalSource, 1, &BufID);
		alBufferData(BufID, AL_FORMAT_STEREO16, sndalQueue, BLOCK_SIZE<<2, FREQ_VAL_FREE);
       		alSourceQueueBuffers(sndalSource, 1, &BufID);

		alGetSourcei(sndalSource, AL_SOURCE_STATE, (int*)&BufID);
		if(BufID!=AL_PLAYING)
		{
			alSourcePlay(sndalSource);
		}
	}
        return true;
}


void _sndal_Destroy()
{
  alSourceStop ( sndalSource );
  // Î÷èùàåì âñå áóôôåðà
  alDeleteBuffers(BLOCK_COUNT, sndalBuffs);
  alDeleteSources(1, &sndalSource);
  // Âûêëþ÷àåì òåêóùèé êîíòåêñò
  alcMakeContextCurrent(NULL);
  // Óíè÷òîæàåì êîíòåêñò
  alcDestroyContext(pContext);
  // Çàêðûâàåì çâóêîâîå óñòðîéñòâî
  alcCloseDevice(pDevice);
}

int _sndal_BufUsage()
{
	return (100*Processed)/BLOCK_COUNT;
}