rtoss - Diff between revs 14 and 26

Subversion Repositories:
Rev:
Only display areas with differences - Ignore whitespace
Rev 14 Rev 26
1 #include <windows.h> 1 #include <windows.h>
2 #include <math.h> 2 #include <math.h>
3 #include "maplay.h" 3 #include "maplay.h"
4 #include "helper.h" 4 #include "helper.h"
5 #include "player.h" 5 #include "player.h"
6 #include "libovd.h" 6 #include "libovd.h"
7 7
8 #define INITIAL_THREAD_PRIORITY         THREAD_PRIORITY_BELOW_NORMAL 8 #define INITIAL_THREAD_PRIORITY         THREAD_PRIORITY_BELOW_NORMAL
9 9
10 CPlayer::CPlayer() : 10 CPlayer::CPlayer() :
11 m_Echo(TRUE), m_Reverb(FALSE) 11 m_Echo(TRUE), m_Reverb(FALSE)
12 { 12 {
13         m_hwndMessage = NULL; 13         m_hwndMessage = NULL;
14         m_szFile[0] = NULL; 14         m_szFile[0] = NULL;
15 15
16         m_dwThreadID = 0; 16         m_dwThreadID = 0;
17         m_hThread = NULL; 17         m_hThread = NULL;
18 18
19         m_nDuration = 0; 19         m_nDuration = 0;
20         m_nSeek = 0; 20         m_nSeek = 0;
21         m_nWritten = 0; 21         m_nWritten = 0;
22         m_fSuppress = FALSE; 22         m_fSuppress = FALSE;
23         m_Status = MAP_STATUS_STOP; 23         m_Status = MAP_STATUS_STOP;
24         m_StreamingStatus = MAP_STREAMING_DISABLED; 24         m_StreamingStatus = MAP_STREAMING_DISABLED;
25         memset(&m_Info, 0, sizeof(MPEG_AUDIO_INFO)); 25         memset(&m_Info, 0, sizeof(MPEG_AUDIO_INFO));
26 26
27         m_fOpen = OPEN_NONE; 27         m_fOpen = OPEN_NONE;
28         m_fStop = FALSE; 28         m_fStop = FALSE;
29         29        
30         m_Options.nThreadPriority = THREAD_PRIORITY_ABOVE_NORMAL; 30         m_Options.nThreadPriority = THREAD_PRIORITY_ABOVE_NORMAL;
31         m_Output.GetOutputParam((LPDWORD)&m_Options.nOutputBufferLen, 31         m_Output.GetOutputParam((LPDWORD)&m_Options.nOutputBufferLen,
32                                                         &m_Options.fAlwaysOpenDevice, &m_Options.fFadeIn); 32                                                         &m_Options.fAlwaysOpenDevice, &m_Options.fFadeIn);
33         //m_Options.fAlwaysOpenDevice = TRUE; 33         //m_Options.fAlwaysOpenDevice = TRUE;
34         m_Options.nOutputPrebuffer = 10; -  
-   34         m_Options.nOutputPrebuffer = 50;
35         m_Options.fScanMpegCompletely = FALSE; 35         m_Options.fScanMpegCompletely = FALSE;
36         m_Options.fFadeIn = FALSE; 36         m_Options.fFadeIn = FALSE;
37         m_Options.fSuppressZeroSamples = FALSE; 37         m_Options.fSuppressZeroSamples = FALSE;
38 38
39         m_pOutHdr = NULL; 39         m_pOutHdr = NULL;
40         m_cbOutBuf = 0; 40         m_cbOutBuf = 0;
41         m_cbOutBufLeft = 0; 41         m_cbOutBufLeft = 0;
42         m_fPlay = FALSE; 42         m_fPlay = FALSE;
43         m_fSeek = FALSE; 43         m_fSeek = FALSE;
44         m_fFileBegin = TRUE; 44         m_fFileBegin = TRUE;
45 45
46         m_Decoder.GetEqualizer(&m_Equalizer); 46         m_Decoder.GetEqualizer(&m_Equalizer);
47         m_fPreamp = FALSE; 47         m_fPreamp = FALSE;
48         m_nPreamp = 31; 48         m_nPreamp = 31;
49         m_nPreampRate = PREAMP_FIXED_FLAT; 49         m_nPreampRate = PREAMP_FIXED_FLAT;
50 50
51         m_hOvd = NULL; 51         m_hOvd = NULL;
52         m_pOvd_buf = NULL; 52         m_pOvd_buf = NULL;
53         m_fNet = NET_OPEN_NONE; 53         m_fNet = NET_OPEN_NONE;
54         m_szOvdTitle[0] = NULL; 54         m_szOvdTitle[0] = NULL;
55 55
56         m_hAcm = NULL; 56         m_hAcm = NULL;
57         m_pwfxSrc = NULL; 57         m_pwfxSrc = NULL;
58         m_pwfxDst = NULL; 58         m_pwfxDst = NULL;
59         m_llDataOffset = 0; 59         m_llDataOffset = 0;
60         m_dwDataSize = 0; 60         m_dwDataSize = 0;
61         m_dwCurrentSize = 0; 61         m_dwCurrentSize = 0;
62 62
63         PlugInLoad(); 63         PlugInLoad();
64 } 64 }
65 65
66 CPlayer::~CPlayer() 66 CPlayer::~CPlayer()
67 { 67 {
68         Close(); 68         Close();
69         m_Output.CloseAll(); 69         m_Output.CloseAll();
70         PlugInFree(); 70         PlugInFree();
71 } 71 }
72 72
73 BOOL CPlayer::OpenFile(LPCTSTR pszFile) 73 BOOL CPlayer::OpenFile(LPCTSTR pszFile)
74 { 74 {
75         CAutoLock lock(&m_csecInterface); 75         CAutoLock lock(&m_csecInterface);
76         Close(); 76         Close();
77 77
78         m_fFileBegin = TRUE; 78         m_fFileBegin = TRUE;
79 79
80         // PlugIn 80         // PlugIn
81         if (PlugInOpenFile(pszFile)) 81         if (PlugInOpenFile(pszFile))
82                 return TRUE; 82                 return TRUE;
83 83
84         // MPEG Audio 84         // MPEG Audio
85         if (MpgOpenFile(pszFile)) 85         if (MpgOpenFile(pszFile))
86                 return TRUE; 86                 return TRUE;
87         87        
88         // Ogg Vorbis 88         // Ogg Vorbis
89         if (OvOpenFile(pszFile)) 89         if (OvOpenFile(pszFile))
90                 return TRUE; 90                 return TRUE;
91 91
92         // Wave 92         // Wave
93         if (WavOpenFile(pszFile)) 93         if (WavOpenFile(pszFile))
94                 return TRUE; 94                 return TRUE;
95 95
96         return FALSE; 96         return FALSE;
97 } 97 }
98 98
99 BOOL CPlayer::OpenURL(LPCTSTR pszURL) 99 BOOL CPlayer::OpenURL(LPCTSTR pszURL)
100 { 100 {
101         CAutoLock lock(&m_csecInterface); 101         CAutoLock lock(&m_csecInterface);
102         Close(); 102         Close();
103 103
104         if (!m_Receiver.Open(pszURL)) 104         if (!m_Receiver.Open(pszURL))
105                 return FALSE; 105                 return FALSE;
106 106
107         m_fOpen = OPEN_URL; 107         m_fOpen = OPEN_URL;
108         m_StreamingStatus = MAP_STREAMING_DISCONNECTED; 108         m_StreamingStatus = MAP_STREAMING_DISCONNECTED;
109         return TRUE; 109         return TRUE;
110 } 110 }
111 111
112 void CPlayer::Close() 112 void CPlayer::Close()
113 { 113 {
114         CAutoLock lock(&m_csecInterface); 114         CAutoLock lock(&m_csecInterface);
115         Stop(); 115         Stop();
116         116        
117         PlugInClose(); 117         PlugInClose();
118         MpgClose(); 118         MpgClose();
119         OvClose(); 119         OvClose();
120         WavClose(); 120         WavClose();
121         NetClose(); 121         NetClose();
122 122
123         memset(&m_Info, 0, sizeof(m_Info)); 123         memset(&m_Info, 0, sizeof(m_Info));
124         m_szFile[0] = NULL; 124         m_szFile[0] = NULL;
125         m_nDuration = 0; 125         m_nDuration = 0;
126 126
127         m_fOpen = OPEN_NONE; 127         m_fOpen = OPEN_NONE;
128         m_StreamingStatus = MAP_STREAMING_DISABLED; 128         m_StreamingStatus = MAP_STREAMING_DISABLED;
129 } 129 }
130 130
131 BOOL CPlayer::Play() 131 BOOL CPlayer::Play()
132 { 132 {
133         CAutoLock lock(&m_csecInterface); 133         CAutoLock lock(&m_csecInterface);
134         if (m_fOpen == OPEN_NONE) 134         if (m_fOpen == OPEN_NONE)
135                 return FALSE; 135                 return FALSE;
136 136
137         if (m_Status == MAP_STATUS_PAUSE) { 137         if (m_Status == MAP_STATUS_PAUSE) {
138                 Pause(); 138                 Pause();
139                 return TRUE; 139                 return TRUE;
140         } 140         }
141         if (m_Status == MAP_STATUS_STOP) { 141         if (m_Status == MAP_STATUS_STOP) {
142                 m_hThread = CreateThread(NULL, 0, PlayerThreadProc, this, 0, &m_dwThreadID); 142                 m_hThread = CreateThread(NULL, 0, PlayerThreadProc, this, 0, &m_dwThreadID);
143                 return m_hThread != NULL; 143                 return m_hThread != NULL;
144         } 144         }
145         return FALSE; 145         return FALSE;
146 } 146 }
147 147
148 void CPlayer::Pause() 148 void CPlayer::Pause()
149 { 149 {
150         CAutoLock lock(&m_csecInterface); 150         CAutoLock lock(&m_csecInterface);
151         if (m_fOpen == OPEN_NONE) 151         if (m_fOpen == OPEN_NONE)
152                 return; 152                 return;
153 153
154         if (m_fOpen == OPEN_URL) 154         if (m_fOpen == OPEN_URL)
155                 return; 155                 return;
156 156
157         if (m_Status == MAP_STATUS_PLAY) { 157         if (m_Status == MAP_STATUS_PLAY) {
158                 UpdateStatus(MAP_STATUS_PAUSE); 158                 UpdateStatus(MAP_STATUS_PAUSE);
159                 m_Output.Pause(TRUE); 159                 m_Output.Pause(TRUE);
160                 m_fPlay = FALSE; 160                 m_fPlay = FALSE;
161         } 161         }
162         else if (m_Status == MAP_STATUS_PAUSE) { 162         else if (m_Status == MAP_STATUS_PAUSE) {
163                 if (m_Output.GetBufferingCount() == m_Output.GetBufferCount()) 163                 if (m_Output.GetBufferingCount() == m_Output.GetBufferCount())
164                         m_Output.Pause(FALSE); 164                         m_Output.Pause(FALSE);
165                 else 165                 else
166                         m_fPlay = TRUE; 166                         m_fPlay = TRUE;
167                 UpdateStatus(MAP_STATUS_PLAY); 167                 UpdateStatus(MAP_STATUS_PLAY);
168         } 168         }
169 } 169 }
170 170
171 void CPlayer::Stop() 171 void CPlayer::Stop()
172 { 172 {
173         CAutoLock lock(&m_csecInterface); 173         CAutoLock lock(&m_csecInterface);
174         174        
175         if (m_hThread) { 175         if (m_hThread) {
176                 m_fStop = TRUE; 176                 m_fStop = TRUE;
177                 m_Receiver.Stop(); 177                 m_Receiver.Stop();
178                 m_Output.Reset(); 178                 m_Output.Reset();
179                 WaitForSingleObject(m_hThread, INFINITE); 179                 WaitForSingleObject(m_hThread, INFINITE);
180                 CloseHandle(m_hThread); 180                 CloseHandle(m_hThread);
181                 m_hThread = NULL; 181                 m_hThread = NULL;
182         } 182         }
183 183
184         m_nSeek = 0; 184         m_nSeek = 0;
185         m_nWritten = 0; 185         m_nWritten = 0;
186         m_fSuppress = FALSE; 186         m_fSuppress = FALSE;
187         m_fPlay = FALSE; 187         m_fPlay = FALSE;
188         m_fStop = FALSE; 188         m_fStop = FALSE;
189         m_fSeek = FALSE; 189         m_fSeek = FALSE;
190         Seek(0); 190         Seek(0);
191 } 191 }
192 192
193 BOOL CPlayer::Ff(long lSkip) 193 BOOL CPlayer::Ff(long lSkip)
194 { 194 {
195         CAutoLock lock(&m_csecInterface); 195         CAutoLock lock(&m_csecInterface);
196         if (m_fOpen == OPEN_NONE) 196         if (m_fOpen == OPEN_NONE)
197                 return FALSE; 197                 return FALSE;
198 198
199         LONG lTime = GetCurrent(); 199         LONG lTime = GetCurrent();
200         lTime += lSkip; 200         lTime += lSkip;
201         return Seek(lTime); 201         return Seek(lTime);
202 } 202 }
203 203
204 BOOL CPlayer::Rew(long lSkip) 204 BOOL CPlayer::Rew(long lSkip)
205 { 205 {
206         CAutoLock lock(&m_csecInterface); 206         CAutoLock lock(&m_csecInterface);
207         if (m_fOpen == OPEN_NONE) 207         if (m_fOpen == OPEN_NONE)
208                 return FALSE; 208                 return FALSE;
209 209
210         LONG lTime = GetCurrent(); 210         LONG lTime = GetCurrent();
211         lTime -= lSkip; 211         lTime -= lSkip;
212         return Seek(lTime); 212         return Seek(lTime);
213 } 213 }
214 214
215 BOOL CPlayer::Seek(long lTime) 215 BOOL CPlayer::Seek(long lTime)
216 { 216 {
217         CAutoLock lock(&m_csecInterface); 217         CAutoLock lock(&m_csecInterface);
218         CAutoLock lock2(&m_csecThread); 218         CAutoLock lock2(&m_csecThread);
219         if (m_fOpen == OPEN_NONE) 219         if (m_fOpen == OPEN_NONE)
220                 return FALSE; 220                 return FALSE;
221         221        
222         // ŽžŠÔ‚̃`ƒFƒbƒN 222         // ŽžŠÔ‚̃`ƒFƒbƒN
223         if (lTime < 0) 223         if (lTime < 0)
224                 lTime = 0; 224                 lTime = 0;
225         if (lTime >= int((double)m_nDuration / m_Info.nSamplingRate * 1000)) 225         if (lTime >= int((double)m_nDuration / m_Info.nSamplingRate * 1000))
226                 return FALSE; 226                 return FALSE;
227 227
228         BOOL fRet = FALSE; 228         BOOL fRet = FALSE;
229         if (m_fOpen == OPEN_PLUGIN) 229         if (m_fOpen == OPEN_PLUGIN)
230                 fRet = PlugInSeekFile(lTime); 230                 fRet = PlugInSeekFile(lTime);
231         else if (m_fOpen == OPEN_MPG_FILE) 231         else if (m_fOpen == OPEN_MPG_FILE)
232                 fRet = MpgSeekFile(lTime); 232                 fRet = MpgSeekFile(lTime);
233         else if (m_fOpen == OPEN_OV_FILE) 233         else if (m_fOpen == OPEN_OV_FILE)
234                 fRet = OvSeekFile(lTime); 234                 fRet = OvSeekFile(lTime);
235         else if (m_fOpen == OPEN_WAV_FILE) 235         else if (m_fOpen == OPEN_WAV_FILE)
236                 fRet = WavSeekFile(lTime); 236                 fRet = WavSeekFile(lTime);
237 237
238         m_fFileBegin = m_nSeek == 0; 238         m_fFileBegin = m_nSeek == 0;
239         if (fRet) { 239         if (fRet) {
240                 m_nWritten = 0; 240                 m_nWritten = 0;
241                 m_fSuppress = FALSE; 241                 m_fSuppress = FALSE;
242 242
243                 SetThreadPriority(m_hThread, INITIAL_THREAD_PRIORITY); 243                 SetThreadPriority(m_hThread, INITIAL_THREAD_PRIORITY);
244         } 244         }
245 245
246         return fRet; 246         return fRet;
247 } 247 }
248 248
249 void CPlayer::SetMessageWindow(HWND hwndMessage) 249 void CPlayer::SetMessageWindow(HWND hwndMessage)
250 { 250 {
251         m_hwndMessage = hwndMessage; 251         m_hwndMessage = hwndMessage;
252         m_Receiver.SetMessageWindow(hwndMessage); 252         m_Receiver.SetMessageWindow(hwndMessage);
253 } 253 }
254 254
255 long CPlayer::GetCurrent() 255 long CPlayer::GetCurrent()
256 { 256 {
257         CAutoLock lock(&m_csecInterface); 257         CAutoLock lock(&m_csecInterface);
258         if (m_fOpen == OPEN_NONE) 258         if (m_fOpen == OPEN_NONE)
259                 return 0; 259                 return 0;
260 260
261         if (GetStatus() == MAP_STATUS_STOP) 261         if (GetStatus() == MAP_STATUS_STOP)
262                 return (int)(((double)m_nSeek) * 1000 / m_Info.nSamplingRate); 262                 return (int)(((double)m_nSeek) * 1000 / m_Info.nSamplingRate);
263         else 263         else
264                 return (int)(((double)m_Output.GetCurrent() + m_nSeek) * 1000 / m_Info.nSamplingRate); 264                 return (int)(((double)m_Output.GetCurrent() + m_nSeek) * 1000 / m_Info.nSamplingRate);
265 } 265 }
266 266
267 long CPlayer::GetDuration() 267 long CPlayer::GetDuration()
268 { 268 {
269         if (m_fOpen == OPEN_NONE) 269         if (m_fOpen == OPEN_NONE)
270                 return 0; 270                 return 0;
271 271
272         return (int)((double)m_nDuration / m_Info.nSamplingRate * 1000); 272         return (int)((double)m_nDuration / m_Info.nSamplingRate * 1000);
273 } 273 }
274 274
275 MAP_STATUS CPlayer::GetStatus() 275 MAP_STATUS CPlayer::GetStatus()
276 { 276 {
277         return m_Status; 277         return m_Status;
278 } 278 }
279 279
280 void CPlayer::SetEqualizer(EQUALIZER* value) 280 void CPlayer::SetEqualizer(EQUALIZER* value)
281 { 281 {
282         m_Equalizer = *value; 282         m_Equalizer = *value;
283         m_Decoder.SetEqualizer(&m_Equalizer); 283         m_Decoder.SetEqualizer(&m_Equalizer);
284         284        
285         m_fPreamp = value->fEnable; 285         m_fPreamp = value->fEnable;
286         m_nPreamp = value->preamp; 286         m_nPreamp = value->preamp;
287         double dLevel = -((double)value->preamp - 31) * 20 / 31; 287         double dLevel = -((double)value->preamp - 31) * 20 / 31;
288         m_nPreampRate = (int)(pow(10, dLevel / 20) * PREAMP_FIXED_FLAT); 288         m_nPreampRate = (int)(pow(10, dLevel / 20) * PREAMP_FIXED_FLAT);
289 289
290         PlugInSetEqualizer(); 290         PlugInSetEqualizer();
291 } 291 }
292 292
293 void CPlayer::GetEqualizer(EQUALIZER* value) 293 void CPlayer::GetEqualizer(EQUALIZER* value)
294 { 294 {
295         *value = m_Equalizer; 295         *value = m_Equalizer;
296 } 296 }
297 297
298 void CPlayer::SetEffect(int nEffect, EFFECT* value) 298 void CPlayer::SetEffect(int nEffect, EFFECT* value)
299 { 299 {
300         switch (nEffect) { 300         switch (nEffect) {
301         case EFFECT_REVERB: 301         case EFFECT_REVERB:
302                 m_Reverb.SetParameter(value); 302                 m_Reverb.SetParameter(value);
303                 break; 303                 break;
304         case EFFECT_ECHO: 304         case EFFECT_ECHO:
305                 m_Echo.SetParameter(value); 305                 m_Echo.SetParameter(value);
306                 break; 306                 break;
307         case EFFECT_SURROUND: 307         case EFFECT_SURROUND:
308                 m_Surround.SetParameter(value); 308                 m_Surround.SetParameter(value);
309                 break; 309                 break;
310         case EFFECT_3DCHORUS: 310         case EFFECT_3DCHORUS:
311                 m_3DChorus.SetParameter(value); 311                 m_3DChorus.SetParameter(value);
312                 break; 312                 break;
313         } 313         }
314 } 314 }
315 315
316 void CPlayer::GetEffect(int nEffect, EFFECT* value) 316 void CPlayer::GetEffect(int nEffect, EFFECT* value)
317 { 317 {
318         switch (nEffect) { 318         switch (nEffect) {
319         case EFFECT_REVERB: 319         case EFFECT_REVERB:
320                 m_Reverb.GetParameter(value); 320                 m_Reverb.GetParameter(value);
321                 break; 321                 break;
322         case EFFECT_ECHO: 322         case EFFECT_ECHO:
323                 m_Echo.GetParameter(value); 323                 m_Echo.GetParameter(value);
324                 break; 324                 break;
325         case EFFECT_SURROUND: 325         case EFFECT_SURROUND:
326                 m_Surround.GetParameter(value); 326                 m_Surround.GetParameter(value);
327                 break; 327                 break;
328         case EFFECT_3DCHORUS: 328         case EFFECT_3DCHORUS:
329                 m_3DChorus.GetParameter(value); 329                 m_3DChorus.GetParameter(value);
330                 break; 330                 break;
331         } 331         }
332 } 332 }
333 333
334 void CPlayer::SetBassBoostLevel(int nLevel) 334 void CPlayer::SetBassBoostLevel(int nLevel)
335 { 335 {
336         m_BassBoost.SetLevel(nLevel); 336         m_BassBoost.SetLevel(nLevel);
337 } 337 }
338 338
339 int CPlayer::GetBassBoostLevel() 339 int CPlayer::GetBassBoostLevel()
340 { 340 {
341         return m_BassBoost.GetLevel(); 341         return m_BassBoost.GetLevel();
342 } 342 }
343 343
344 void CPlayer::GetFileInformation(MAP_INFORMATION* pInfo) 344 void CPlayer::GetFileInformation(MAP_INFORMATION* pInfo)
345 { 345 {
346         if (m_fOpen == OPEN_NONE) 346         if (m_fOpen == OPEN_NONE)
347                 return; 347                 return;
348         pInfo->nBitRate = m_Info.nBitRate; 348         pInfo->nBitRate = m_Info.nBitRate;
349         pInfo->nChannels = m_Info.nChannels; 349         pInfo->nChannels = m_Info.nChannels;
350         pInfo->nLayer = m_Info.nLayer; 350         pInfo->nLayer = m_Info.nLayer;
351         pInfo->nSamplingRate = m_Info.nSamplingRate; 351         pInfo->nSamplingRate = m_Info.nSamplingRate;
352         pInfo->nVersion = m_Info.nVersion; 352         pInfo->nVersion = m_Info.nVersion;
353         pInfo->nDuration = (int)((double)m_nDuration / m_Info.nSamplingRate * 1000); 353         pInfo->nDuration = (int)((double)m_nDuration / m_Info.nSamplingRate * 1000);
354 } 354 }
355 355
356 BOOL CPlayer::GetId3Tag(ID3TAGV1* pTag) 356 BOOL CPlayer::GetId3Tag(ID3TAGV1* pTag)
357 { 357 {
-   358         BOOL bRet;
358         if (m_fOpen == OPEN_MPG_FILE) 359         if (m_fOpen == OPEN_MPG_FILE)
359                 return MpgGetId3Tag(pTag); -  
-   360                 bRet = MpgGetId3Tag(pTag);
360         else if (m_fOpen == OPEN_OV_FILE) 361         else if (m_fOpen == OPEN_OV_FILE)
361                 return OvGetId3Tag(pTag); -  
-   362                 bRet = OvGetId3Tag(pTag);
362         else if (m_fOpen == OPEN_PLUGIN) 363         else if (m_fOpen == OPEN_PLUGIN)
363                 return PlugInGetId3Tag(pTag); -  
-   364                 bRet = PlugInGetId3Tag(pTag);
364 365
365         return FALSE; -  
-   366         if (!bRet)
-   367                 bRet = ::GetId3Tag(m_szFile, pTag);
-   368
-   369         return bRet;
366 } 370 }
367 371
368 BOOL CPlayer::SetId3Tag(ID3TAGV1* pTag) 372 BOOL CPlayer::SetId3Tag(ID3TAGV1* pTag)
369 { 373 {
370         return FALSE; // not support 374         return FALSE; // not support
371 } 375 }
372 376
373 BOOL CPlayer::GetStreamInfo(LPTSTR pszName, LPTSTR pszGenre, LPTSTR pszURL) 377 BOOL CPlayer::GetStreamInfo(LPTSTR pszName, LPTSTR pszGenre, LPTSTR pszURL)
374 { 378 {
375         return m_Receiver.GetStreamInfo(pszName, pszGenre, pszURL); 379         return m_Receiver.GetStreamInfo(pszName, pszGenre, pszURL);
376 } 380 }
377 381
378 BOOL CPlayer::GetStreamTitle(LPTSTR pszTitle) 382 BOOL CPlayer::GetStreamTitle(LPTSTR pszTitle)
379 { 383 {
380         if (_tcslen(m_szOvdTitle)) { 384         if (_tcslen(m_szOvdTitle)) {
381                 _tcscpy(pszTitle, m_szOvdTitle); 385                 _tcscpy(pszTitle, m_szOvdTitle);
382                 return TRUE; 386                 return TRUE;
383         } 387         }
384 388
385         return m_Receiver.GetStreamTitle(pszTitle); 389         return m_Receiver.GetStreamTitle(pszTitle);
386 } 390 }
387 391
388 void CPlayer::GetOptions(MAP_OPTIONS* pOptions) 392 void CPlayer::GetOptions(MAP_OPTIONS* pOptions)
389 { 393 {
390         *pOptions = m_Options; 394         *pOptions = m_Options;
391 } 395 }
392 396
393 BOOL CPlayer::SetOptions(MAP_OPTIONS* pOptions) 397 BOOL CPlayer::SetOptions(MAP_OPTIONS* pOptions)
394 { 398 {
395         if (m_Status != MAP_STATUS_STOP) 399         if (m_Status != MAP_STATUS_STOP)
396                 return FALSE; 400                 return FALSE;
397 401
398         if (m_Options.nOutputPrebuffer < 0 || m_Options.nOutputPrebuffer > 100) 402         if (m_Options.nOutputPrebuffer < 0 || m_Options.nOutputPrebuffer > 100)
399                 return FALSE; 403                 return FALSE;
400 404
401         if (pOptions->nOutputBufferLen == m_Options.nOutputBufferLen && 405         if (pOptions->nOutputBufferLen == m_Options.nOutputBufferLen &&
402                 pOptions->fAlwaysOpenDevice == m_Options.fAlwaysOpenDevice && 406                 pOptions->fAlwaysOpenDevice == m_Options.fAlwaysOpenDevice &&
403                 pOptions->fFadeIn == m_Options.fFadeIn) { 407                 pOptions->fFadeIn == m_Options.fFadeIn) {
404                 m_Options = *pOptions; 408                 m_Options = *pOptions;
405                 return TRUE; 409                 return TRUE;
406         } 410         }
407 411
408         m_Output.CloseAll(); 412         m_Output.CloseAll();
409         if (!m_Output.SetOutputParam(pOptions->nOutputBufferLen, 413         if (!m_Output.SetOutputParam(pOptions->nOutputBufferLen,
410                                                         pOptions->fAlwaysOpenDevice, pOptions->fFadeIn)) 414                                                         pOptions->fAlwaysOpenDevice, pOptions->fFadeIn))
411                 return FALSE; 415                 return FALSE;
412 416
413         m_Options = *pOptions; 417         m_Options = *pOptions;
414         return TRUE; 418         return TRUE;
415 } 419 }
416 420
417 void CPlayer::GetStreamingOptions(MAP_STREAMING_OPTIONS* pOptions) 421 void CPlayer::GetStreamingOptions(MAP_STREAMING_OPTIONS* pOptions)
418 { 422 {
419         pOptions->nBuf = m_Receiver.GetBufferCount(); 423         pOptions->nBuf = m_Receiver.GetBufferCount();
420         pOptions->nPreBuf = m_Receiver.GetPrebufferingCount(); 424         pOptions->nPreBuf = m_Receiver.GetPrebufferingCount();
421         pOptions->fUseProxy = m_Receiver.GetProxy(pOptions->szProxy); 425         pOptions->fUseProxy = m_Receiver.GetProxy(pOptions->szProxy);
422         m_Receiver.GetUserAgent(pOptions->szUserAgent); 426         m_Receiver.GetUserAgent(pOptions->szUserAgent);
423 } 427 }
424 428
425 BOOL CPlayer::SetStreamingOptions(MAP_STREAMING_OPTIONS* pOptions) 429 BOOL CPlayer::SetStreamingOptions(MAP_STREAMING_OPTIONS* pOptions)
426 { 430 {
427         if (!m_Receiver.SetBufferCount(pOptions->nBuf)) 431         if (!m_Receiver.SetBufferCount(pOptions->nBuf))
428                 return FALSE; 432                 return FALSE;
429 433
430         int nPreBuf = pOptions->nPreBuf; 434         int nPreBuf = pOptions->nPreBuf;
431         if (nPreBuf > pOptions->nBuf) 435         if (nPreBuf > pOptions->nBuf)
432                 nPreBuf = pOptions->nBuf; 436                 nPreBuf = pOptions->nBuf;
433         m_Receiver.SetPrebufferingCount(nPreBuf); 437         m_Receiver.SetPrebufferingCount(nPreBuf);
434         m_Receiver.SetProxy(pOptions->fUseProxy, pOptions->szProxy); 438         m_Receiver.SetProxy(pOptions->fUseProxy, pOptions->szProxy);
435         m_Receiver.SetUserAgent(pOptions->szUserAgent); 439         m_Receiver.SetUserAgent(pOptions->szUserAgent);
436 440
437         return TRUE; 441         return TRUE;
438 } 442 }
439 443
440 MAP_STREAMING_STATUS CPlayer::GetStreamingStatus() 444 MAP_STREAMING_STATUS CPlayer::GetStreamingStatus()
441 { 445 {
442         return m_StreamingStatus; 446         return m_StreamingStatus;
443 } 447 }
444 448
445 int CPlayer::GetStreamingBufferingCount() 449 int CPlayer::GetStreamingBufferingCount()
446 { 450 {
447         if (m_StreamingStatus < MAP_STREAMING_CONNECTING) 451         if (m_StreamingStatus < MAP_STREAMING_CONNECTING)
448                 return 0; 452                 return 0;
449 453
450         return m_Receiver.GetBufferingCount(); 454         return m_Receiver.GetBufferingCount();
451 } 455 }
452 456
453 // protected members 457 // protected members
454 458
455 void CPlayer::PostCallbackMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) 459 void CPlayer::PostCallbackMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
456 { 460 {
457         PostMessage(m_hwndMessage, uMsg, wParam, lParam); 461         PostMessage(m_hwndMessage, uMsg, wParam, lParam);
458 } 462 }
459 463
460 void CPlayer::UpdateStatus(MAP_STATUS status, BOOL fError) 464 void CPlayer::UpdateStatus(MAP_STATUS status, BOOL fError)
461 { 465 {
462         if (m_Status != status) { 466         if (m_Status != status) {
463                 m_Status = status; 467                 m_Status = status;
464                 PostCallbackMessage(MAP_MSG_STATUS, status, fError); 468                 PostCallbackMessage(MAP_MSG_STATUS, status, fError);
465         } 469         }
466 } 470 }
467 471
468 void CPlayer::UpdatePeek() 472 void CPlayer::UpdatePeek()
469 { 473 {
470         PostCallbackMessage(MAP_MSG_PEEK, m_Output.m_nLPeek, m_Output.m_nRPeek); 474         PostCallbackMessage(MAP_MSG_PEEK, m_Output.m_nLPeek, m_Output.m_nRPeek);
471 } 475 }
472 476
473 BOOL CPlayer::PreparePlayback() 477 BOOL CPlayer::PreparePlayback()
474 { 478 {
475         if (m_fStop) 479         if (m_fStop)
476                 return FALSE; 480                 return FALSE;
477 481
478         CAutoLock lock(&m_csecInterface); 482         CAutoLock lock(&m_csecInterface);
479 483
480         int nBitsPerSample; 484         int nBitsPerSample;
481         switch (m_fOpen) { 485         switch (m_fOpen) {
482         case OPEN_WAV_FILE: 486         case OPEN_WAV_FILE:
483                 nBitsPerSample = m_pwfxDst->wBitsPerSample; break; 487                 nBitsPerSample = m_pwfxDst->wBitsPerSample; break;
484         case OPEN_PLUGIN: 488         case OPEN_PLUGIN:
485                 nBitsPerSample = m_nPlugInBps; break; 489                 nBitsPerSample = m_nPlugInBps; break;
486         default: 490         default:
487                 nBitsPerSample = 16; 491                 nBitsPerSample = 16;
488         } 492         }
489 493
490         if (!m_Output.Open(m_Info.nChannels, m_Info.nSamplingRate, nBitsPerSample)) 494         if (!m_Output.Open(m_Info.nChannels, m_Info.nSamplingRate, nBitsPerSample))
491                 return FALSE; 495                 return FALSE;
492 496
493         m_cbOutBuf = m_Output.GetBufferSize(); 497         m_cbOutBuf = m_Output.GetBufferSize();
494         m_Output.Pause(TRUE); 498         m_Output.Pause(TRUE);
495 499
496         m_Decoder.Init(); 500         m_Decoder.Init();
497         m_BassBoost.Open(m_Info.nChannels, m_Info.nSamplingRate); 501         m_BassBoost.Open(m_Info.nChannels, m_Info.nSamplingRate);
498         m_Echo.Open(m_Info.nChannels, m_Info.nSamplingRate); 502         m_Echo.Open(m_Info.nChannels, m_Info.nSamplingRate);
499         m_Reverb.Open(m_Info.nChannels, m_Info.nSamplingRate); 503         m_Reverb.Open(m_Info.nChannels, m_Info.nSamplingRate);
500 504
501         if (m_Info.nChannels == 2) 505         if (m_Info.nChannels == 2)
502                 m_3DChorus.Open(m_Info.nSamplingRate); 506                 m_3DChorus.Open(m_Info.nSamplingRate);
503 507
504         m_fPlay = TRUE; 508         m_fPlay = TRUE;
505         m_fStop = FALSE; 509         m_fStop = FALSE;
506         SetThreadPriority(m_hThread, INITIAL_THREAD_PRIORITY); 510         SetThreadPriority(m_hThread, INITIAL_THREAD_PRIORITY);
507 511
508         return TRUE; 512         return TRUE;
509 } 513 }
510 514
511 BOOL CPlayer::UnpreparePlayback(BOOL fEos, BOOL fError) 515 BOOL CPlayer::UnpreparePlayback(BOOL fEos, BOOL fError)
512 { 516 {
513         if (fEos) { 517         if (fEos) {
514                 if (m_pOutHdr) { 518                 if (m_pOutHdr) {
515                         OutputBuffer(m_pOutHdr, m_cbOutBuf - m_cbOutBufLeft); 519                         OutputBuffer(m_pOutHdr, m_cbOutBuf - m_cbOutBufLeft);
516                         m_pOutHdr = NULL; 520                         m_pOutHdr = NULL;
517                         m_cbOutBufLeft = 0; 521                         m_cbOutBufLeft = 0;
518                 } 522                 }
519                 while (!m_Output.IsFlushed()) { 523                 while (!m_Output.IsFlushed()) {
520                         if (m_fPlay && GetStatus() == MAP_STATUS_PLAY) { 524                         if (m_fPlay && GetStatus() == MAP_STATUS_PLAY) {
521                                 m_Output.Pause(FALSE); 525                                 m_Output.Pause(FALSE);
522                                 m_fPlay = FALSE; 526                                 m_fPlay = FALSE;
523                         } 527                         }
524                         Sleep(1); 528                         Sleep(1);
525                         if (m_fSeek) 529                         if (m_fSeek)
526                                 return FALSE; 530                                 return FALSE;
527                         if (m_fStop) 531                         if (m_fStop)
528                                 break; 532                                 break;
529                         UpdatePeek(); 533                         UpdatePeek();
530                 } 534                 }
531         } 535         }
532 536
533         m_Output.Close(); 537         m_Output.Close();
534         m_Echo.Close(); 538         m_Echo.Close();
535         m_Reverb.Close(); 539         m_Reverb.Close();
536         m_BassBoost.Close(); 540         m_BassBoost.Close();
537         m_3DChorus.Close(); 541         m_3DChorus.Close();
538         m_Decoder.Destroy(); 542         m_Decoder.Destroy();
539 543
540         if (!m_Options.fAlwaysOpenDevice || fError) 544         if (!m_Options.fAlwaysOpenDevice || fError)
541                 m_Output.CloseAll(); 545                 m_Output.CloseAll();
542 546
543         if (m_fOpen == OPEN_URL) { 547         if (m_fOpen == OPEN_URL) {
544                 m_Receiver.Disconnect(); 548                 m_Receiver.Disconnect();
545                 m_StreamingStatus = MAP_STREAMING_DISCONNECTED; 549                 m_StreamingStatus = MAP_STREAMING_DISCONNECTED;
546         } 550         }
547 551
548         m_pOutHdr = NULL; 552         m_pOutHdr = NULL;
549         m_cbOutBufLeft = 0; 553         m_cbOutBufLeft = 0;
550 554
551         m_nSeek = 0; 555         m_nSeek = 0;
552         m_fPlay = FALSE; 556         m_fPlay = FALSE;
553         m_fStop = FALSE; 557         m_fStop = FALSE;
554         m_fSeek = FALSE; 558         m_fSeek = FALSE;
555 559
556         switch (m_fOpen) { 560         switch (m_fOpen) {
557         case OPEN_PLUGIN: 561         case OPEN_PLUGIN:
558                 PlugInStop(); break; 562                 PlugInStop(); break;
559         case OPEN_MPG_FILE: 563         case OPEN_MPG_FILE:
560                 MpgStop(); break; 564                 MpgStop(); break;
561         case OPEN_OV_FILE: 565         case OPEN_OV_FILE:
562                 OvStop(); break; 566                 OvStop(); break;
563         case OPEN_WAV_FILE: 567         case OPEN_WAV_FILE:
564                 WavStop(); break; 568                 WavStop(); break;
565         case OPEN_URL: 569         case OPEN_URL:
566                 NetStop(); break; 570                 NetStop(); break;
567         } 571         }
568 572
569         PostMessage(m_hwndMessage, MAP_MSG_PEEK, 0, 0); 573         PostMessage(m_hwndMessage, MAP_MSG_PEEK, 0, 0);
570         UpdateStatus(MAP_STATUS_STOP, fError); 574         UpdateStatus(MAP_STATUS_STOP, fError);
571         return TRUE; 575         return TRUE;
572 } 576 }
573 577
574 void CPlayer::OutputBuffer(WAVEHDR* pHdr, DWORD cbRecorded) 578 void CPlayer::OutputBuffer(WAVEHDR* pHdr, DWORD cbRecorded)
575 { 579 {
576         int nBitsPerSample; 580         int nBitsPerSample;
577         switch (m_fOpen) { 581         switch (m_fOpen) {
578         case OPEN_WAV_FILE: 582         case OPEN_WAV_FILE:
579                 nBitsPerSample = m_pwfxDst->wBitsPerSample; break; 583                 nBitsPerSample = m_pwfxDst->wBitsPerSample; break;
580         case OPEN_PLUGIN: 584         case OPEN_PLUGIN:
581                 nBitsPerSample = m_nPlugInBps; break; 585                 nBitsPerSample = m_nPlugInBps; break;
582         default: 586         default:
583                 nBitsPerSample = 16; 587                 nBitsPerSample = 16;
584         } 588         }
585 589
586         // æ“ª‚Ì–³‰¹ƒTƒ“ƒvƒ‹‚̏œ‹Ž 590         // æ“ª‚Ì–³‰¹ƒTƒ“ƒvƒ‹‚̏œ‹Ž
587         if (m_fOpen != OPEN_URL) { 591         if (m_fOpen != OPEN_URL) {
588                 if (m_fFileBegin) { 592                 if (m_fFileBegin) {
589                         m_Output.SetFadeOff(); 593                         m_Output.SetFadeOff();
590                         if (m_Options.fSuppressZeroSamples) { 594                         if (m_Options.fSuppressZeroSamples) {
591                                 DWORD cb = m_Output.ScanZeroSamples(TRUE, (BYTE*)pHdr->lpData, cbRecorded); 595                                 DWORD cb = m_Output.ScanZeroSamples(TRUE, (BYTE*)pHdr->lpData, cbRecorded);
592                                 if (cb == cbRecorded) { 596                                 if (cb == cbRecorded) {
593                                         pHdr->dwBytesRecorded = 0; 597                                         pHdr->dwBytesRecorded = 0;
594                                         m_Output.OutputBuffer(pHdr); 598                                         m_Output.OutputBuffer(pHdr);
595                                         m_nSeek += cb / (m_Info.nChannels * (nBitsPerSample / 8)); 599                                         m_nSeek += cb / (m_Info.nChannels * (nBitsPerSample / 8));
596 #ifdef _WIN32_WCE 600 #ifdef _WIN32_WCE
597                                         Sleep(1); 601                                         Sleep(1);
598 #endif 602 #endif
599                                         return; 603                                         return;
600                                 } 604                                 }
601                                 else { 605                                 else {
602                                         cbRecorded -= cb; 606                                         cbRecorded -= cb;
603                                         memmove(pHdr->lpData, pHdr->lpData + cb, cbRecorded); 607                                         memmove(pHdr->lpData, pHdr->lpData + cb, cbRecorded);
604                                         m_nSeek += cb / (m_Info.nChannels * (nBitsPerSample / 8)); 608                                         m_nSeek += cb / (m_Info.nChannels * (nBitsPerSample / 8));
605                                 } 609                                 }
606                         } 610                         }
607                         m_fFileBegin = FALSE; 611                         m_fFileBegin = FALSE;
608                 } 612                 }
609                 else { 613                 else {
610                         // ƒtƒ@ƒCƒ‹––”ö‚Ì–³‰¹‚̏œ‹Ž 614                         // ƒtƒ@ƒCƒ‹––”ö‚Ì–³‰¹‚̏œ‹Ž
611                         if (m_Options.fSuppressZeroSamples) { 615                         if (m_Options.fSuppressZeroSamples) {
612                                 if (m_fSuppress) { 616                                 if (m_fSuppress) {
613                                         pHdr->dwBytesRecorded = 0; 617                                         pHdr->dwBytesRecorded = 0;
614                                         m_Output.OutputBuffer(pHdr); 618                                         m_Output.OutputBuffer(pHdr);
615                                         return; 619                                         return;
616                                 } 620                                 }
617 621
618                                 if (m_nWritten + m_nSeek >= m_nDuration - (m_Info.nSamplingRate * 10)) { // ––’[10•b‚É“ž’B‚µ‚½‚©H 622                                 if (m_nWritten + m_nSeek >= m_nDuration - (m_Info.nSamplingRate * 10)) { // ––’[10•b‚É“ž’B‚µ‚½‚©H
619                                         DWORD cb = m_Output.ScanZeroSamples(FALSE, (BYTE*)pHdr->lpData, cbRecorded); 623                                         DWORD cb = m_Output.ScanZeroSamples(FALSE, (BYTE*)pHdr->lpData, cbRecorded);
620                                         if ((int)cb > m_Info.nChannels * m_Info.nSamplingRate * (nBitsPerSample / 8) / 100) { // 10ƒ~ƒŠ•bˆÈã–³‰¹‚ª‚ ‚é‚©H 624                                         if ((int)cb > m_Info.nChannels * m_Info.nSamplingRate * (nBitsPerSample / 8) / 100) { // 10ƒ~ƒŠ•bˆÈã–³‰¹‚ª‚ ‚é‚©H
621                                                 cbRecorded -= cb; 625                                                 cbRecorded -= cb;
622                                                 m_fSuppress = TRUE; 626                                                 m_fSuppress = TRUE;
623                                         } 627                                         }
624                                 } 628                                 }
625                         } 629                         }
626                 } 630                 }
627         } 631         }
628         632        
629         pHdr->dwBufferLength = pHdr->dwBytesRecorded = cbRecorded; 633         pHdr->dwBufferLength = pHdr->dwBytesRecorded = cbRecorded;
630 634
631         // ƒGƒtƒFƒNƒg‚̏ˆ— 635         // ƒGƒtƒFƒNƒg‚̏ˆ—
632         short* p = (short*)pHdr->lpData; 636         short* p = (short*)pHdr->lpData;
633         if (m_Info.nChannels == 2) { 637         if (m_Info.nChannels == 2) {
634                 m_3DChorus.Process(nBitsPerSample, (LPBYTE)p, cbRecorded); 638                 m_3DChorus.Process(nBitsPerSample, (LPBYTE)p, cbRecorded);
635                 m_Surround.Process(nBitsPerSample, p, cbRecorded); 639                 m_Surround.Process(nBitsPerSample, p, cbRecorded);
636         } 640         }
637 641
638         m_BassBoost.Process(nBitsPerSample, p, cbRecorded); 642         m_BassBoost.Process(nBitsPerSample, p, cbRecorded);
639         m_Echo.Process(nBitsPerSample, p, cbRecorded); 643         m_Echo.Process(nBitsPerSample, p, cbRecorded);
640         m_Reverb.Process(nBitsPerSample, p, cbRecorded); 644         m_Reverb.Process(nBitsPerSample, p, cbRecorded);
641 645
642         // ƒs[ƒNƒ[ƒ^‚ðXV 646         // ƒs[ƒNƒ[ƒ^‚ðXV
643         UpdatePeek(); 647         UpdatePeek();
644 648
645         // o—Í 649         // o—Í
646         m_Output.OutputBuffer(pHdr); 650         m_Output.OutputBuffer(pHdr);
647         m_nWritten += pHdr->dwBytesRecorded / (nBitsPerSample / 8 * m_Info.nChannels); 651         m_nWritten += pHdr->dwBytesRecorded / (nBitsPerSample / 8 * m_Info.nChannels);
648 652
649         // Ä¶ŠJŽn’Ê’m 653         // Ä¶ŠJŽn’Ê’m
650         if (m_fPlay && GetStatus() == MAP_STATUS_PLAY) { 654         if (m_fPlay && GetStatus() == MAP_STATUS_PLAY) {
651                 if ((int)m_Output.GetBufferingSamples() >= 655                 if ((int)m_Output.GetBufferingSamples() >=
652                         ((m_Info.nSamplingRate * m_Options.nOutputBufferLen) / 1000) * m_Options.nOutputPrebuffer / 100) { 656                         ((m_Info.nSamplingRate * m_Options.nOutputBufferLen) / 1000) * m_Options.nOutputPrebuffer / 100) {
653                         m_Output.Pause(FALSE); 657                         m_Output.Pause(FALSE);
654                         m_fPlay = FALSE; 658                         m_fPlay = FALSE;
655 659
656                         ::SetThreadPriority(m_hThread, m_Options.nThreadPriority); 660                         ::SetThreadPriority(m_hThread, m_Options.nThreadPriority);
657                 } 661                 }
658                 else if (m_Output.GetBufferingCount() == m_Output.GetBufferCount()) { 662                 else if (m_Output.GetBufferingCount() == m_Output.GetBufferCount()) {
659                         m_Output.Pause(FALSE); 663                         m_Output.Pause(FALSE);
660                         m_fPlay = FALSE; 664                         m_fPlay = FALSE;
661 665
662                         ::SetThreadPriority(m_hThread, m_Options.nThreadPriority); 666                         ::SetThreadPriority(m_hThread, m_Options.nThreadPriority);
663                 } 667                 }
664         } 668         }
665 } 669 }
666 670
667 void CPlayer::AudioDeviceClose() 671 void CPlayer::AudioDeviceClose()
668 { 672 {
669         if (m_Status != MAP_STATUS_STOP) 673         if (m_Status != MAP_STATUS_STOP)
670                 Stop(); 674                 Stop();
671 675
672         m_Output.CloseAll(); 676         m_Output.CloseAll();
673 } 677 }
674 678
675 void CPlayer::GetBufferInfo(DWORD* pcbTotalAudio, DWORD* pcbBufferedAudio, 679 void CPlayer::GetBufferInfo(DWORD* pcbTotalAudio, DWORD* pcbBufferedAudio,
676                                                         DWORD* pcbTotalStream, DWORD* pcbBufferedStream) 680                                                         DWORD* pcbTotalStream, DWORD* pcbBufferedStream)
677 { 681 {
678         m_Output.GetBufferInfo(pcbTotalAudio, pcbBufferedAudio); 682         m_Output.GetBufferInfo(pcbTotalAudio, pcbBufferedAudio);
679         m_Receiver.GetBufferInfo(pcbTotalStream, pcbBufferedStream); 683         m_Receiver.GetBufferInfo(pcbTotalStream, pcbBufferedStream);
680 } 684 }
681 685
682 BOOL CPlayer::WaitForPrebuffering(int nBuffering) 686 BOOL CPlayer::WaitForPrebuffering(int nBuffering)
683 { 687 {
684         if (!nBuffering) 688         if (!nBuffering)
685                 nBuffering = m_Receiver.GetPrebufferingCount(); 689                 nBuffering = m_Receiver.GetPrebufferingCount();
686 690
687         while (TRUE) { 691         while (TRUE) {
688                 if (m_fStop) 692                 if (m_fStop)
689                         return FALSE; 693                         return FALSE;
690                 if (!m_Receiver.IsConnected()) 694                 if (!m_Receiver.IsConnected())
691                         return m_Receiver.IsEos() ? TRUE : FALSE; 695                         return m_Receiver.IsEos() ? TRUE : FALSE;
692 696
693                 if (m_Receiver.GetBufferingCount() >= nBuffering) 697                 if (m_Receiver.GetBufferingCount() >= nBuffering)
694                         return TRUE; 698                         return TRUE;
695 699
696                 Sleep(1); 700                 Sleep(1);
697         } 701         }
698 } 702 }
699 703
700 void CPlayer::Preamp(LPBYTE pbBuf, DWORD cbBuf) 704 void CPlayer::Preamp(LPBYTE pbBuf, DWORD cbBuf)
701 { 705 {
702         if (m_fPreamp) 706         if (m_fPreamp)
703                 m_Output.Preamp(pbBuf, cbBuf, m_nPreampRate); 707                 m_Output.Preamp(pbBuf, cbBuf, m_nPreampRate);
704 } 708 }
705 709
706 DWORD WINAPI CPlayer::PlayerThreadProc(LPVOID pParam) 710 DWORD WINAPI CPlayer::PlayerThreadProc(LPVOID pParam)
707 { 711 {
708         CPlayer* pPlayer = (CPlayer*)pParam; 712         CPlayer* pPlayer = (CPlayer*)pParam;
709 713
710         if (pPlayer->m_fOpen == OPEN_URL) 714         if (pPlayer->m_fOpen == OPEN_URL)
711                 pPlayer->NetStreamingThread(); 715                 pPlayer->NetStreamingThread();
712         else 716         else
713                 pPlayer->FilePlayerThread(); 717                 pPlayer->FilePlayerThread();
714 718
715         return 0; 719         return 0;
716 } 720 }
717 721
718 void CPlayer::FilePlayerThread() 722 void CPlayer::FilePlayerThread()
719 { 723 {
720         int nRet = RET_ERROR; 724         int nRet = RET_ERROR;
721 725
722         UpdateStatus(MAP_STATUS_WAIT); 726         UpdateStatus(MAP_STATUS_WAIT);
723         if (!PreparePlayback()) { 727         if (!PreparePlayback()) {
724                 UnpreparePlayback(FALSE, TRUE); 728                 UnpreparePlayback(FALSE, TRUE);
725                 return; 729                 return;
726         } 730         }
727         UpdateStatus(MAP_STATUS_PLAY); 731         UpdateStatus(MAP_STATUS_PLAY);
728 732
729 retry: 733 retry:
730         switch (m_fOpen) { 734         switch (m_fOpen) {
731         case OPEN_PLUGIN: 735         case OPEN_PLUGIN:
732                 nRet = PlugInPlayerThread(); break; 736                 nRet = PlugInPlayerThread(); break;
733         case OPEN_MPG_FILE: 737         case OPEN_MPG_FILE:
734                 nRet = MpgPlayerThread(); break; 738                 nRet = MpgPlayerThread(); break;
735         case OPEN_OV_FILE: 739         case OPEN_OV_FILE:
736                 nRet = OvPlayerThread(); break; 740                 nRet = OvPlayerThread(); break;
737         case OPEN_WAV_FILE: 741         case OPEN_WAV_FILE:
738                 nRet = WavPlayerThread(); break; 742                 nRet = WavPlayerThread(); break;
739         } 743         }
740 744
741         switch (nRet) { 745         switch (nRet) {
742         case RET_EOF: 746         case RET_EOF:
743                 if (!UnpreparePlayback(TRUE)) 747                 if (!UnpreparePlayback(TRUE))
744                         goto retry; 748                         goto retry;
745                 break; 749                 break;
746         case RET_STOP: 750         case RET_STOP:
747                 UnpreparePlayback(); 751                 UnpreparePlayback();
748                 break; 752                 break;
749         case RET_ERROR: 753         case RET_ERROR:
750                 UnpreparePlayback(FALSE, TRUE); 754                 UnpreparePlayback(FALSE, TRUE);
751                 break; 755                 break;
-   756         }
-   757 }
-   758
-   759 DWORD CPlayer::GetVolume(BOOL bSysVolume)
-   760 {
-   761         DWORD dwVolume = 0;
-   762         if (bSysVolume) {
-   763                 waveOutGetVolume(NULL, &dwVolume);
-   764                 return dwVolume;
-   765         }
-   766         else {
-   767                 return m_Output.GetVolume();
-   768         }
-   769 }
-   770
-   771 void CPlayer::SetVolume(DWORD dwVolume, BOOL bSysVolume)
-   772 {
-   773         if (bSysVolume) {
-   774                 waveOutSetVolume(NULL, dwVolume);
-   775         }
-   776         else {
-   777                 m_Output.SetVolume(dwVolume);
752         } 778         }
753 } 779 }
754   780