Debian Codegraph @

lib/aviplay/IAudioRenderer.cpp

raw
1 /*********************************************************
2
3 Implementation of base audio renderer class
4
5 *********************************************************/
6
7 #include "IAudioRenderer.h"
8 #include "AudioQueue.h"
9
10 #include "avm_cpuinfo.h"
11 #include "avm_output.h"
12 #include "audiodecoder.h"
13 #include "avifile.h"
14 #include "utils.h"
15
16 #include <stdio.h>
17
18 AVM_BEGIN_NAMESPACE;
19
20 IAudioRenderer::IAudioRenderer(IReadStream* as, WAVEFORMATEX& Owf)
21 : m_pAudiostream(as), m_pQueue(0),
22 m_llTimeStart(0), m_uiSamples(0),
23 m_Owf(Owf), m_iBalance(BAL_MAX/2), m_iVolume(VOL_MAX),
24 m_bQuit(false), m_bPaused(false), m_bInitialized(false)
25 {
26 m_dSeekTime = m_dStreamTime = m_dAudioRealpos = m_dPauseTime = m_pAudiostream->GetTime();
27
28 // needed for bitrate in nAvgBytesPerSec
29 WAVEFORMATEX Inwf;
30 m_pAudiostream->GetAudioFormat(&Inwf, sizeof(Inwf));
31 m_pAudiostream->GetOutputFormat(&m_Iwf, sizeof(m_Iwf));
32
33 // format can't be changed
34 m_Owf.wFormatTag = m_Iwf.wFormatTag;
35 m_Owf.nBlockAlign = m_Iwf.nBlockAlign;
36
37 if (m_Owf.nChannels == 0)
38 {
39 m_Owf.nChannels = m_Iwf.nChannels;
40 if (m_Owf.nChannels > 2)
41 m_Owf.nChannels = 2;
42 }
43
44 if (m_Owf.nSamplesPerSec == 0)
45 m_Owf.nSamplesPerSec = m_Iwf.nSamplesPerSec;
46
47 if (m_Owf.wBitsPerSample == 0)
48 {
49 m_Owf.wBitsPerSample = m_Iwf.wBitsPerSample;
50 if (m_Owf.wBitsPerSample > 16)
51 m_Owf.wBitsPerSample = 16;
52 }
53
54 m_Owf.nBlockAlign = (uint16_t) (m_Owf.nChannels * ((m_Owf.wBitsPerSample + 7) / 8));
55 m_Owf.nAvgBytesPerSec = m_Owf.nSamplesPerSec * m_Owf.nBlockAlign;
56
57 m_dOwfBPS = m_Owf.nAvgBytesPerSec;
58 m_dIwfBPS = m_Iwf.nSamplesPerSec * m_Owf.nChannels /* tricky */
59 * ((m_Owf.wBitsPerSample + 7) / 8);
60
61 char b[200];
62 avm_wave_format(b, sizeof(b), &Inwf);
63 AVM_WRITE("audio renderer", "src %s\n", b);
64 avm_wave_format(b, sizeof(b), &m_Owf);
65 AVM_WRITE("audio renderer", "dst %s\n", b);
66
67 // no need to catch - we allocate m_pQueue as last object
68 m_pQueue = new AudioQueue(m_Iwf, m_Owf);
69 SetAsync(0.);
70 }
71
72 IAudioRenderer::~IAudioRenderer()
73 {
74 delete m_pQueue;
75 }
76
77 const char* IAudioRenderer::GetAudioFormat() const
78 {
79 return m_pAudiostream->GetAudioDecoder()->GetCodecInfo().GetName();
80 }
81
82 bool IAudioRenderer::Eof() const
83 {
84 //if (m_pAudiostream->Eof())
85 // AVM_WRITE("audio renderer", "Audio EOF: %d --- bt:%f ren:%f %f\n", m_pAudiostream->Eof(), GetBufferTime(), getRendererBufferTime(), m_pAudiostream->GetTime());
86 return m_pAudiostream->Eof() && ((GetBufferTime() - getRendererBufferTime()) < 0.01);
87 }
88
89 int IAudioRenderer::Extract()
90 {
91 if (m_pAudiostream->Eof() || m_pQueue->IsFull())
92 return -1; // reader is supposed to wait!!
93
94 size_t frame_size = m_pAudiostream->GetFrameSize();
95 if (frame_size < 2048)
96 frame_size = 2048;
97 size_t ocnt;
98 size_t samples;
99 char* frame = new char[frame_size + 2048]; // safety reason
100 if (!frame)
101 return -1;
102 //AVM_WRITE("audio renderer", 1, "before st: %f\n", m_pAudiostream->GetTime());
103 //for (int i = 0; i < 64; i++) printf("%d 0x%x\n", i, (unsigned char) m_pcLocalFrame[i]);
104 m_pAudiostream->ReadFrames(frame, frame_size, frame_size, samples, ocnt);
105 //if (m_uiSamples < 100000) printf("Ocnt %d %d %d\n", ocnt, samples, frame_size);
106
107 if ((int)ocnt <= 0)
108 {
109 delete[] frame;
110 if (ocnt == 0) // && m_uiSamples > 0)
111 {
112 m_dSeekTime = m_pAudiostream->GetTime();
113 m_uiSamples = 0;
114 AVM_WRITE("audio renderer", 1, "new seektime set: %f (eof:%d)\n", m_dSeekTime, m_pAudiostream->Eof());
115 }
116 return 0;
117 }
118 if (samples > frame_size)
119 AVM_WRITE("audio renderer", "OOPS: samples (%" PRIsz ") > one_frame_sound (%" PRIsz ")\n", samples, frame_size);
120
121 if (ocnt > frame_size)
122 {
123 AVM_WRITE("audio renderer", "OOPS: ocnt (%" PRIsz ") > one_frame_sound (%" PRIsz ")\n", ocnt, frame_size);
124 ocnt = frame_size;
125 }
126
127 m_pQueue->Lock();
128 m_pQueue->Write(frame, ocnt);
129 m_uiSamples += ocnt;
130 m_dStreamTime = m_pAudiostream->GetTime();
131 m_pQueue->Unlock();
132 //AVM_WRITE("audio renderer", 1, "extracted %d sample(s) (%d bytes) newtime: %f %d %f\n", samples, ocnt, m_dStreamTime, m_uiSamples, m_dOwfBPS);
133 return 0;
134 }
135
136 double IAudioRenderer::GetBufferTime() const
137 {
138 if (!m_bInitialized)
139 return 0.;
140
141 //AVM_WRITE("audio renderer", "GBT %f %f\n", m_pQueue->GetBufferTime(), getRendererBufferTime());
142 double btime = m_pQueue->GetBufferTime() + getRendererBufferTime();
143 //printf("BTIME %f %f %f\n", btime, m_pQueue->GetBufferTime(),getRendererBufferTime());
144 return btime;
145 }
146
147 double IAudioRenderer::GetCacheSize() const
148 {
149 return m_pAudiostream->CacheSize();
150 }
151
152 double IAudioRenderer::GetLengthTime() const
153 {
154 return m_pAudiostream->GetLengthTime();
155 }
156
157 double IAudioRenderer::GetTime()
158 {
159 //printf("GetTime %f %d\n", m_dPauseTime, m_bPaused);
160 if (m_dPauseTime != -1.)
161 return m_dPauseTime;
162
163 double actual_time = avm_get_time_diff(avm_get_time_us(), m_llTimeStart)
164 + m_dAudioRealpos - m_fAsync;
165
166 //AVM_WRITE("audio renderer", "stream: %f buffered: %f actual: %f\n",
167 // m_pAudiostream->GetTime(), GetBufferTime(), actual_time);
168 //actual_time = m_pAudiostream->GetTime() - GetBufferTime();
169 return (actual_time > 0.) ? actual_time : 0.;
170 }
171
172 int IAudioRenderer::Pause(bool state)
173 {
174 m_pQueue->Lock();
175 if (!m_bInitialized)
176 {
177 m_pQueue->Unlock();
178 return -1;
179 }
180
181 if (m_bPaused != state)
182 {
183 m_bPaused = state;
184 pause((state) ? 1 : 0);
185 if (state)
186 {
187 m_dPauseTime = GetTime();
188 reset();
189 }
190 }
191 m_pQueue->Broadcast(); // in case audio renderer waits for new data
192 m_pQueue->Unlock();
193 return 0;
194 }
195
196 int IAudioRenderer::SeekTime(double pos)
197 {
198 m_pQueue->Lock();
199 pos += m_fAsync;
200 if (pos < 0.)
201 pos = 0.;
202 int hr = 0;
203 m_llTimeStart = 0;
204
205 if (m_bInitialized)
206 {
207 if (pos < m_pAudiostream->GetTime())
208 hr = m_pAudiostream->SeekTime(pos);
209 else
210 m_pAudiostream->SkipTo(pos);
211 m_pQueue->Clear();
212 reset();
213 }
214 else
215 hr = m_pAudiostream->SeekTime(pos);
216 m_dSeekTime = m_dStreamTime = m_dAudioRealpos = m_dPauseTime = m_pAudiostream->GetTime();
217 m_uiSamples = 0;
218 //AVM_WRITE("audio renderer", "AUDIOREALPOS %f to %f\n", m_dAudioRealpos, pos);
219 m_pQueue->Unlock();
220 return hr;
221 }
222
223 /*
224 int IAudioRenderer::Skip(double skiptime)
225 {
226 Locker locker(m_Mutex);
227 int r = m_pAudiostream->SkipTo(skiptime);
228 m_dStreamTime = m_dAudioRealpos = m_pAudiostream->GetTime();
229
230 return r;
231 }
232 */
233
234 int IAudioRenderer::GetBalance()
235 {
236 return m_iBalance;
237 }
238
239 int IAudioRenderer::GetVolume()
240 {
241 return m_iVolume;
242 }
243
244 int IAudioRenderer::SetBalance(int balance)
245 {
246 if (balance < 0 || balance > BAL_MAX)
247 return -1;
248
249 m_iBalance = balance;
250 return 0;
251 }
252
253 int IAudioRenderer::SetVolume(int volume)
254 {
255 if (volume < 0 || volume > VOL_MAX)
256 return -1;
257
258 m_iVolume = volume;
259 return 0;
260 }
261
262 void IAudioRenderer::Start()
263 {
264 m_pQueue->Lock();
265 if (!m_bInitialized)
266 {
267 m_bInitialized = true;
268 m_bPaused = false;
269 pause(0);
270 } else {
271 AVM_WRITE("audio renderer", "already started\n");
272 }
273 m_pQueue->Unlock();
274 }
275
276 void IAudioRenderer::Stop()
277 {
278 m_pQueue->Lock();
279 if (m_bInitialized)
280 {
281 m_bInitialized = false;
282 m_pQueue->Clear();
283 pause(1);
284 }
285 m_pQueue->Unlock();
286 return;
287 }
288
289 void IAudioRenderer::updateTimer()
290 {
291 double nt = GetStreamTime() - GetBufferTime() - m_fAsync;
292 //printf("NT time %f %f\n", nt - GetTime(), nt);
293 if (nt < 0.) nt = 0.;
294
295 if (m_dPauseTime != -1.)
296 {
297 m_dAudioRealpos = nt;
298 m_llTimeStart = avm_get_time_us();
299 m_dPauseTime = -1.;
300 }
301 else
302 {
303 const double df = 0.04;
304 double st = GetTime();
305 double dt = st - nt;
306
307 //AVM_WRITE("audio renderer", "nt:%.4f st:%.4f dt:%.4f t:%.4f bt:%.4f df:%.4f\n", nt, st, dt,
308 // GetStreamTime(), GetBufferTime(), getRendererBufferTime());
309 if (dt < -df || dt > df)
310 {
311 AVM_WRITE("audio renderer", 1, "stime %f %f dt: %f t: %f b: %f rt: %f\n",
312 nt, st, dt, GetStreamTime(), GetBufferTime(), getRendererBufferTime());
313 // we need bigger jump when sound is going slower!
314 m_dAudioRealpos -= dt / 20;
315 }
316 }
317 }
318
319 AVM_END_NAMESPACE;