Debian Codegraph @

lib/aviplay/AudioQueue.cpp

raw
1 /**********************************************
2
3 Audio queue implementation
4
5 **********************************************/
6
7 #include "AudioQueue.h"
8 #include "AudioCleaner.h"
9 #include "IAudioResampler.h"
10 #include "avm_output.h"
11
12 #if 1
13 // slower but has much better precision
14 #define RESAMPLERSTEREO AudioFpHQResamplerStereo
15 #define RESAMPLERMONO AudioFpHQResamplerMono
16 #include "AudioFpHQResampler.h"
17 #else
18 // faster but not very good method
19 #define RESAMPLERSTEREO AudioIntResamplerStereo
20 #define RESAMPLERMONO AudioIntResamplerMono
21 #include "AudioIntResampler.h"
22 #endif
23
24 #include "avm_cpuinfo.h"
25 #include "utils.h"
26
27 #include <unistd.h> //write
28 #include <string.h> //memcpy
29 #include <stdio.h>
30
31 //#undef Debug
32 //#define Debug if (0)
33 // using different strategy - caller is responsible for holding lock!
34
35 AVM_BEGIN_NAMESPACE;
36
37 template<class T> inline T mymin(const T x, const T y)
38 {
39 return (x < y) ? x : y;
40 }
41
42 AudioQueue::AudioQueue(WAVEFORMATEX& Iwf, WAVEFORMATEX& Owf) : m_Bufs(64)
43 {
44 m_dRemains = 0.0;
45 m_pResampler = 0;
46 m_pCleaner = 0;
47 m_Iwf = Iwf;
48 m_Owf = Owf;
49 m_uiBytesPerSec = (m_Owf.nChannels * ((m_Owf.wBitsPerSample + 7) / 8)
50 * m_Owf.nSamplesPerSec);
51
52 for (size_t i = 0; i < m_Bufs.capacity(); i++)
53 m_Bufs[i].mem = 0;
54
55 m_uiBufSize = 0;
56 m_bCleared = false;
57
58 //printf("QUEUE %x %x\n", m_Iwf.wFormatTag, m_Owf.wFormatTag);
59 if (m_Owf.wFormatTag == 0x01)
60 {
61 uint_t clearsz = (m_uiBytesPerSec / 10) & ~3U; // 0.1 sec
62
63 // for PCM (0x01) we could add some silent to remove clics & pops
64 m_pCleaner = CreateAudioCleaner(m_Owf.nChannels, m_Owf.wBitsPerSample,
65 clearsz);
66 }
67 }
68
69 AudioQueue::~AudioQueue()
70 {
71 m_Mutex.Lock(); // just for safety
72 Clear();
73 m_Mutex.Unlock();
74 delete m_pCleaner;
75 delete m_pResampler;
76 }
77
78 void AudioQueue::Clear()
79 {
80 AVM_WRITE("aviplay", 2, "AudioQueue: clear\n");
81
82 for (size_t i = 0; i < m_Bufs.capacity(); i++)
83 {
84 delete[] m_Bufs[i].mem;
85 m_Bufs[i].mem = 0;
86 }
87 m_Bufs.clear();
88 m_bCleared = true;
89 m_uiBufSize = 0;
90 if (m_pCleaner)
91 m_pCleaner->soundOff(0, 0);
92 m_Cond.Broadcast();
93 }
94
95 void AudioQueue::DisableCleaner()
96 {
97 delete m_pCleaner;
98 m_pCleaner = 0;
99 }
100
101
102 /* ineffective */
103 ssize_t AudioQueue::Resample(void* dest, const void* src, size_t src_size)
104 {
105 if (m_Iwf.wBitsPerSample != m_Owf.wBitsPerSample
106 || m_Iwf.nChannels != m_Owf.nChannels
107 || (m_Iwf.nChannels != 1 && m_Iwf.nChannels != 2))
108 {
109 #if 0
110 cerr << "AudioQueue::resample() unsupported resampling conversion!" << endl
111 << "From: bps: " << m_Iwf.wBitsPerSample
112 << " ch: " << m_Iwf.nChannels
113 << " To: bps: " << m_Owf.wBitsPerSample
114 << " ch: " << m_Owf.nChannels << endl;
115 #endif
116 return 0;
117 }
118
119 if (!m_pResampler || (int)m_pResampler->getBitsPerSample() != m_Owf.wBitsPerSample)
120 {
121 delete m_pResampler;
122
123 m_pResampler = CreateHQResampler(m_Owf.nChannels, m_Owf.wBitsPerSample);
124
125 if (!m_pResampler)
126 {
127 AVM_WRITE("aviplay", "AudioQueue::resample() creation of resampler failed\n");
128 return 0;
129 }
130 }
131 double ndest_size = (double) src_size / m_Iwf.nSamplesPerSec * m_Owf.nSamplesPerSec
132 / (m_Owf.wBitsPerSample / 8 * m_Owf.nChannels);
133
134 src_size /= (m_Iwf.wBitsPerSample / 8 * m_Iwf.nChannels);
135 size_t dest_size = (size_t) ndest_size;
136
137 m_dRemains += (ndest_size - (double)dest_size);
138 if (m_dRemains > 1.0)
139 {
140 m_dRemains -= 1.0;
141 dest_size++;
142 }
143
144 //cout << "dest_size " << dest_size << " orig " << ndest_size << endl;
145
146 AVM_WRITE("aviplay", 2, "AudioQueue::resample() freq: %" PRIsz " -> %" PRIsz "\n", src_size, dest_size);
147 if (dest_size > 0)
148 m_pResampler->resample(dest, src, dest_size, src_size);
149
150 //cout << "resampled " << src_size<< " to " << dest_size
151 // << " >>> " << src_size << " b:" << m_Owf.wBitsPerSample
152 // << " ch:" << m_Owf.nChannels << endl;
153 return (ssize_t) (dest_size * (m_Owf.wBitsPerSample / 8) * m_Owf.nChannels);
154 }
155
156 ssize_t AudioQueue::Read(void* data, size_t count, const IAudioMix* amix)
157 {
158 //AVM_WRITE("aviplay", 2, "AudioQueue: read: %d\n", count);
159
160 size_t bread = 0;
161 while (bread < count && !m_Bufs.empty())
162 {
163 chunk& rchunk = m_Bufs.front();
164 size_t r = rchunk.size - rchunk.rsize;
165 if (r > (count - bread))
166 r = (count - bread);
167
168 if (amix == 0)
169 memcpy((char*)data + bread, rchunk.mem + rchunk.rsize, r);
170 else
171 {
172 r = amix->Mix((char*)data + bread, rchunk.mem + rchunk.rsize, r);
173 if (r <= 0)
174 break;
175 }
176 //printf("ReadAudioChunk %d %d\n", rchunk.rsize, r);
177 rchunk.rsize += r;
178 bread += r;
179 if (rchunk.rsize >= rchunk.size)
180 {
181 delete[] rchunk.mem;
182 rchunk.mem = 0;
183 m_Bufs.pop();
184 }
185 }
186
187 if (m_Bufs.empty() && !bread)
188 AVM_WRITE("aviplay", "AudioQueue::Read() Warning: audio queue drain\n");
189
190 m_uiBufSize -= bread;
191 m_Cond.Broadcast();
192
193 return bread;
194 }
195
196 ssize_t AudioQueue::Write(char* data, size_t count)
197 {
198 //AVM_WRITE("aviplay", 2, "AudioQueue::Write(%d) %d\n", count, m_uiBufSize);
199
200 size_t new_count = count * m_Owf.nSamplesPerSec / m_Iwf.nSamplesPerSec + 16;
201
202 chunk newch;
203
204 newch.mem = data;
205 newch.size = count;
206
207 if (m_Iwf.nSamplesPerSec != m_Owf.nSamplesPerSec)
208 {
209 if (!(newch.mem = new char[new_count]))
210 return -1;
211
212 newch.size = Resample(newch.mem, data, count);
213 delete[] data;
214 }
215
216 #if 0
217 // checking if the sample continues correctly
218 short *p = (short*) (m_pcAudioFrame + ((m_uiFrameIn > 64) ? m_uiFrameIn : 64));
219
220 for (int i = -32; i < 32; i++)
221 {
222 if (!(i % 8))
223 printf("\n%4d ", i);
224 //printf(" 0x%4.4x", abs(p[i] - p[i-2]) & 0xffff);
225 printf(" 0x%4.4x", p[i] & 0xffff);
226 }
227 #endif
228
229 if (m_bCleared && m_pCleaner)
230 m_bCleared = (m_pCleaner->soundOn(newch.mem, newch.size) != 0);
231
232 newch.rsize = 0;
233 m_Bufs.push(newch);
234 m_uiBufSize += newch.size;
235 m_Cond.Broadcast();
236
237 return 0;
238 }
239
240 AVM_END_NAMESPACE;