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 "maplay.h" 2 #include "maplay.h"
3 #include "helper.h" 3 #include "helper.h"
4 #include "player.h" 4 #include "player.h"
5 5
6 typedef struct _PLUGIN_INFO { 6 typedef struct _PLUGIN_INFO {
7         HMODULE                         hModule; 7         HMODULE                         hModule;
8         MAP_DEC_PLUGIN*         pPlugIn; 8         MAP_DEC_PLUGIN*         pPlugIn;
9         DWORD                           dwFunc; 9         DWORD                           dwFunc;
10 } PLUGIN_INFO; 10 } PLUGIN_INFO;
11 11
12 void CPlayer::PlugInLoad() 12 void CPlayer::PlugInLoad()
13 { 13 {
14         BOOL fLoad; 14         BOOL fLoad;
15         HMODULE hModule; 15         HMODULE hModule;
16         WIN32_FIND_DATA wfd; 16         WIN32_FIND_DATA wfd;
17         TCHAR szPath[MAX_PATH]; 17         TCHAR szPath[MAX_PATH];
18         TCHAR szModule[MAX_PATH]; 18         TCHAR szModule[MAX_PATH];
19         PLUGIN_INFO* pInfo; 19         PLUGIN_INFO* pInfo;
20         MAP_DEC_PLUGIN* pPlugIn; 20         MAP_DEC_PLUGIN* pPlugIn;
21         MAP_DEC_PLUGIN* (WINAPI *pmapGetDecoder)(); 21         MAP_DEC_PLUGIN* (WINAPI *pmapGetDecoder)();
22 22
23         m_nFilePlugIn = -1; 23         m_nFilePlugIn = -1;
24         m_nStreamingPlugIn = -1; 24         m_nStreamingPlugIn = -1;
25         m_nPlugInBps = 0; 25         m_nPlugInBps = 0;
26 26
27         GetModuleFileName(NULL, szModule, MAX_PATH); 27         GetModuleFileName(NULL, szModule, MAX_PATH);
28         LPTSTR p = _tcsrchr(szModule, _T('\\')); 28         LPTSTR p = _tcsrchr(szModule, _T('\\'));
29         if (p) *p = NULL; 29         if (p) *p = NULL;
30 30
31         wsprintf(szPath, _T("%s\\*.dll"), szModule); 31         wsprintf(szPath, _T("%s\\*.dll"), szModule);
32         32        
33         HANDLE hFind = FindFirstFile(szPath, &wfd); 33         HANDLE hFind = FindFirstFile(szPath, &wfd);
34         if (hFind != INVALID_HANDLE_VALUE) { 34         if (hFind != INVALID_HANDLE_VALUE) {
35                 do { 35                 do {
36                         fLoad = FALSE; 36                         fLoad = FALSE;
37                         if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { 37                         if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
38                                 wsprintf(szPath, _T("%s\\%s"), szModule, wfd.cFileName); 38                                 wsprintf(szPath, _T("%s\\%s"), szModule, wfd.cFileName);
39                                 hModule = LoadLibrary(szPath); 39                                 hModule = LoadLibrary(szPath);
40                                 if (hModule) { 40                                 if (hModule) {
41 #ifdef _WIN32_WCE 41 #ifdef _WIN32_WCE
42                                         (FARPROC&)pmapGetDecoder = GetProcAddress(hModule, _T("mapGetDecoder")); 42                                         (FARPROC&)pmapGetDecoder = GetProcAddress(hModule, _T("mapGetDecoder"));
43 #else 43 #else
44                                         (FARPROC&)pmapGetDecoder = GetProcAddress(hModule, "mapGetDecoder"); 44                                         (FARPROC&)pmapGetDecoder = GetProcAddress(hModule, "mapGetDecoder");
45 #endif 45 #endif
46                                         if (pmapGetDecoder) { 46                                         if (pmapGetDecoder) {
47                                                 pPlugIn = pmapGetDecoder(); 47                                                 pPlugIn = pmapGetDecoder();
48                                                 if (pPlugIn && pPlugIn->dwVersion == PLUGIN_DEC_VER && 48                                                 if (pPlugIn && pPlugIn->dwVersion == PLUGIN_DEC_VER &&
49                                                         pPlugIn->Init && pPlugIn->Quit && pPlugIn->GetPluginName && 49                                                         pPlugIn->Init && pPlugIn->Quit && pPlugIn->GetPluginName &&
50                                                         pPlugIn->SetEqualizer && pPlugIn->ShowConfigDlg && 50                                                         pPlugIn->SetEqualizer && pPlugIn->ShowConfigDlg &&
51                                                         pPlugIn->GetFileExtCount && pPlugIn->GetFileExt && 51                                                         pPlugIn->GetFileExtCount && pPlugIn->GetFileExt &&
52                                                         pPlugIn->IsValidFile && 52                                                         pPlugIn->IsValidFile &&
53                                                         pPlugIn->OpenFile && pPlugIn->SeekFile && 53                                                         pPlugIn->OpenFile && pPlugIn->SeekFile &&
54                                                         pPlugIn->StartDecodeFile && pPlugIn->DecodeFile && 54                                                         pPlugIn->StartDecodeFile && pPlugIn->DecodeFile &&
55                                                         pPlugIn->StopDecodeFile && pPlugIn->CloseFile && 55                                                         pPlugIn->StopDecodeFile && pPlugIn->CloseFile &&
56                                                         pPlugIn->GetTag && pPlugIn->GetFileTag && 56                                                         pPlugIn->GetTag && pPlugIn->GetFileTag &&
57                                                         pPlugIn->OpenStreaming && pPlugIn->DecodeStreaming && 57                                                         pPlugIn->OpenStreaming && pPlugIn->DecodeStreaming &&
58                                                         pPlugIn->CloseStreaming && pPlugIn->dwChar == sizeof(TCHAR)) { 58                                                         pPlugIn->CloseStreaming && pPlugIn->dwChar == sizeof(TCHAR)) {
59 59
60                                                         pPlugIn->Init(); 60                                                         pPlugIn->Init();
61 61
62                                                         pInfo = new PLUGIN_INFO; 62                                                         pInfo = new PLUGIN_INFO;
63                                                         pInfo->hModule = hModule; 63                                                         pInfo->hModule = hModule;
64                                                         pInfo->pPlugIn = pPlugIn; 64                                                         pInfo->pPlugIn = pPlugIn;
65                                                         pInfo->dwFunc = pPlugIn->GetFunc(); 65                                                         pInfo->dwFunc = pPlugIn->GetFunc();
66                                                         m_PlugInInfo.Add((DWORD)pInfo); 66                                                         m_PlugInInfo.Add((DWORD)pInfo);
67                                                         67                                                        
68                                                         fLoad = TRUE;   68                                                         fLoad = TRUE;  
69                                                 } 69                                                 }
70                                         } 70                                         }
71                                         if (!fLoad) FreeLibrary(hModule); 71                                         if (!fLoad) FreeLibrary(hModule);
72                                 } 72                                 }
73                         } 73                         }
74                 } 74                 }
75                 while (FindNextFile(hFind, &wfd)); 75                 while (FindNextFile(hFind, &wfd));
76                 FindClose(hFind); 76                 FindClose(hFind);
77         } 77         }
78 } 78 }
79 79
80 void CPlayer::PlugInFree() 80 void CPlayer::PlugInFree()
81 { 81 {
82         PLUGIN_INFO* pInfo; 82         PLUGIN_INFO* pInfo;
83         while (!m_PlugInInfo.IsEmpty()) { 83         while (!m_PlugInInfo.IsEmpty()) {
84                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.RemoveAt(0); 84                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.RemoveAt(0);
85                 pInfo->pPlugIn->Quit(); 85                 pInfo->pPlugIn->Quit();
86                 FreeLibrary(pInfo->hModule); 86                 FreeLibrary(pInfo->hModule);
87                 delete pInfo; 87                 delete pInfo;
88         } 88         }
89 } 89 }
90 90
91 BOOL CPlayer::PlugInIsValidFile(LPCTSTR pszFile) 91 BOOL CPlayer::PlugInIsValidFile(LPCTSTR pszFile)
92 { 92 {
93         PLUGIN_INFO* pInfo; 93         PLUGIN_INFO* pInfo;
94         int nCount = m_PlugInInfo.GetCount(); 94         int nCount = m_PlugInInfo.GetCount();
95         for (int i = 0; i < nCount; i++) { 95         for (int i = 0; i < nCount; i++) {
96                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i); 96                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i);
97                                 97                                
98                 if (pInfo->dwFunc & PLUGIN_FUNC_DECFILE) { 98                 if (pInfo->dwFunc & PLUGIN_FUNC_DECFILE) {
99                         if (pInfo->pPlugIn->IsValidFile(pszFile)) 99                         if (pInfo->pPlugIn->IsValidFile(pszFile))
100                                 return TRUE; 100                                 return TRUE;
101                 } 101                 }
102         } 102         }
103         return FALSE; 103         return FALSE;
104 } 104 }
105 105
106 BOOL CPlayer::PlugInGetId3TagFile(LPCTSTR pszFile, ID3TAGV1* pTag) 106 BOOL CPlayer::PlugInGetId3TagFile(LPCTSTR pszFile, ID3TAGV1* pTag)
107 { 107 {
108         PLUGIN_INFO* pInfo; 108         PLUGIN_INFO* pInfo;
109         int nCount = m_PlugInInfo.GetCount(); 109         int nCount = m_PlugInInfo.GetCount();
110         for (int i = 0; i < nCount; i++) { 110         for (int i = 0; i < nCount; i++) {
111                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i); 111                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i);
112                                 112                                
113                 if (pInfo->dwFunc & PLUGIN_FUNC_FILETAG) { 113                 if (pInfo->dwFunc & PLUGIN_FUNC_FILETAG) {
114                         MAP_PLUGIN_FILETAG tag = {0}; 114                         MAP_PLUGIN_FILETAG tag = {0};
115                         if (pInfo->pPlugIn->GetFileTag(pszFile, &tag)) { 115                         if (pInfo->pPlugIn->GetFileTag(pszFile, &tag)) {
116                                 pTag->nYear = tag.nYear; 116                                 pTag->nYear = tag.nYear;
117                                 pTag->nTrackNum = tag.nTrackNum; 117                                 pTag->nTrackNum = tag.nTrackNum;
118                                 _tcscpy(pTag->szGenre, tag.szGenre); 118                                 _tcscpy(pTag->szGenre, tag.szGenre);
119                                 _tcscpy(pTag->szAlbum, tag.szAlbum); 119                                 _tcscpy(pTag->szAlbum, tag.szAlbum);
120                                 _tcscpy(pTag->szArtist, tag.szArtist); 120                                 _tcscpy(pTag->szArtist, tag.szArtist);
121                                 _tcscpy(pTag->szComment, tag.szComment); 121                                 _tcscpy(pTag->szComment, tag.szComment);
122                                 _tcscpy(pTag->szTrack, tag.szTrack); 122                                 _tcscpy(pTag->szTrack, tag.szTrack);
123                                 return TRUE; 123                                 return TRUE;
124                         } 124                         }
125                 } 125                 }
126         } 126         }
127         return FALSE; 127         return FALSE;
128 } 128 }
129 129
130 BOOL CPlayer::PlugInOpenFile(LPCTSTR pszFile) 130 BOOL CPlayer::PlugInOpenFile(LPCTSTR pszFile)
131 { 131 {
132         PLUGIN_INFO* pInfo; 132         PLUGIN_INFO* pInfo;
133         MAP_PLUGIN_FILE_INFO info; 133         MAP_PLUGIN_FILE_INFO info;
134         int nCount = m_PlugInInfo.GetCount(); 134         int nCount = m_PlugInInfo.GetCount();
135         for (int i = 0; i < nCount; i++) { 135         for (int i = 0; i < nCount; i++) {
136                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i); 136                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i);
137                 if (pInfo->dwFunc & PLUGIN_FUNC_DECFILE) { 137                 if (pInfo->dwFunc & PLUGIN_FUNC_DECFILE) {
138                         if (pInfo->pPlugIn->OpenFile(pszFile, &info)) { 138                         if (pInfo->pPlugIn->OpenFile(pszFile, &info)) {
139                                 memset(&m_Info, 0, sizeof(m_Info)); 139                                 memset(&m_Info, 0, sizeof(m_Info));
140                                 m_Info.nChannels = info.nChannels; 140                                 m_Info.nChannels = info.nChannels;
141                                 m_Info.nSamplingRate = info.nSampleRate; 141                                 m_Info.nSamplingRate = info.nSampleRate;
142                                 m_Info.nBitRate = info.nAvgBitrate; 142                                 m_Info.nBitRate = info.nAvgBitrate;
143                                 m_nPlugInBps = info.nBitsPerSample; 143                                 m_nPlugInBps = info.nBitsPerSample;
144                                 m_Info.nFrameSize = 0; 144                                 m_Info.nFrameSize = 0;
145                                 m_Info.nSamplesPerFrame = 0; 145                                 m_Info.nSamplesPerFrame = 0;
146                                 m_nDuration = (int)(((double)info.nDuration * m_Info.nSamplingRate) / 1000); 146                                 m_nDuration = (int)(((double)info.nDuration * m_Info.nSamplingRate) / 1000);
147 147
148                                 m_nFilePlugIn = i; 148                                 m_nFilePlugIn = i;
149                                 m_fOpen = OPEN_PLUGIN; 149                                 m_fOpen = OPEN_PLUGIN;
150                                 return TRUE; 150                                 return TRUE;
151                         } 151                         }
152                 } 152                 }
153         } 153         }
154 154
155         return FALSE; 155         return FALSE;
156 } 156 }
157 157
158 BOOL CPlayer::PlugInSeekFile(long lTime) 158 BOOL CPlayer::PlugInSeekFile(long lTime)
159 { 159 {
160         if (m_nFilePlugIn == -1) 160         if (m_nFilePlugIn == -1)
161                 return FALSE; 161                 return FALSE;
162 162
163         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn); 163         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn);
164         if (!(pInfo->dwFunc & PLUGIN_FUNC_SEEKFILE)) 164         if (!(pInfo->dwFunc & PLUGIN_FUNC_SEEKFILE))
165                 return FALSE; 165                 return FALSE;
166 166
167         long lSeek = pInfo->pPlugIn->SeekFile(lTime); 167         long lSeek = pInfo->pPlugIn->SeekFile(lTime);
168         if (lSeek == -1) 168         if (lSeek == -1)
169                 return FALSE; 169                 return FALSE;
170 170
171         m_fSeek = TRUE; 171         m_fSeek = TRUE;
172         m_nSeek = (int)((double)lSeek * m_Info.nSamplingRate / 1000); 172         m_nSeek = (int)((double)lSeek * m_Info.nSamplingRate / 1000);
173         m_Output.Reset(); 173         m_Output.Reset();
174 174
175         return TRUE; 175         return TRUE;
176 } 176 }
177 177
178 DWORD CPlayer::PlugInPlayerThread() 178 DWORD CPlayer::PlugInPlayerThread()
179 { 179 {
180         if (m_nFilePlugIn == -1) 180         if (m_nFilePlugIn == -1)
181                 return RET_ERROR; 181                 return RET_ERROR;
182 182
183         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn); 183         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn);
184 184
185         if (!pInfo->pPlugIn->StartDecodeFile()) 185         if (!pInfo->pPlugIn->StartDecodeFile())
186                 return RET_ERROR; 186                 return RET_ERROR;
187 187
188         int nRet; 188         int nRet;
189         while (TRUE) { 189         while (TRUE) {
190                 if (m_fStop) 190                 if (m_fStop)
191                         return RET_STOP; 191                         return RET_STOP;
192 192
193                 if (!m_pOutHdr) 193                 if (!m_pOutHdr)
194                         m_pOutHdr = m_Output.GetBuffer(); 194                         m_pOutHdr = m_Output.GetBuffer();
195 195
196                 { 196                 {
197                         CAutoLock lock(&m_csecThread); 197                         CAutoLock lock(&m_csecThread);
198                         if (m_fSeek) { 198                         if (m_fSeek) {
199                                 if (m_Status == MAP_STATUS_PLAY) 199                                 if (m_Status == MAP_STATUS_PLAY)
200                                         m_fPlay = TRUE; 200                                         m_fPlay = TRUE;
201 201
202                                 m_Reverb.Reset(); 202                                 m_Reverb.Reset();
203                                 m_Echo.Reset(); 203                                 m_Echo.Reset();
204                                 m_BassBoost.Reset(); 204                                 m_BassBoost.Reset();
205                                 m_3DChorus.Reset(); 205                                 m_3DChorus.Reset();
206                                 m_Output.Reset(); 206                                 m_Output.Reset();
207                                 m_fSeek = FALSE; 207                                 m_fSeek = FALSE;
208                                 m_pOutHdr = NULL; 208                                 m_pOutHdr = NULL;
209                                 continue; 209                                 continue;
210                         } 210                         }
211                 211                
212                         m_pOutHdr->dwBytesRecorded = 0; 212                         m_pOutHdr->dwBytesRecorded = 0;
213                         m_pOutHdr->dwBufferLength = m_cbOutBuf; 213                         m_pOutHdr->dwBufferLength = m_cbOutBuf;
214                         nRet = pInfo->pPlugIn->DecodeFile(m_pOutHdr); 214                         nRet = pInfo->pPlugIn->DecodeFile(m_pOutHdr);
215                 } 215                 }
216 216
217                 if (nRet == PLUGIN_RET_ERROR) 217                 if (nRet == PLUGIN_RET_ERROR)
218                         return RET_ERROR; 218                         return RET_ERROR;
219                 219                
220                 if (!(pInfo->dwFunc & PLUGIN_FUNC_EQ)) 220                 if (!(pInfo->dwFunc & PLUGIN_FUNC_EQ))
221                         Preamp((LPBYTE)m_pOutHdr->lpData, m_pOutHdr->dwBytesRecorded); 221                         Preamp((LPBYTE)m_pOutHdr->lpData, m_pOutHdr->dwBytesRecorded);
222 222
223                 OutputBuffer(m_pOutHdr, m_pOutHdr->dwBytesRecorded); 223                 OutputBuffer(m_pOutHdr, m_pOutHdr->dwBytesRecorded);
224                 m_pOutHdr = NULL; 224                 m_pOutHdr = NULL;
225 225
226                 if (nRet == PLUGIN_RET_EOF) 226                 if (nRet == PLUGIN_RET_EOF)
227                         return RET_EOF; 227                         return RET_EOF;
228 228
229                 if (m_fSuppress) 229                 if (m_fSuppress)
230                         return RET_EOF; 230                         return RET_EOF;
231         } 231         }
232 } 232 }
233 233
234 void CPlayer::PlugInStop() 234 void CPlayer::PlugInStop()
235 { 235 {
236         if (m_nFilePlugIn == -1) 236         if (m_nFilePlugIn == -1)
237                 return; 237                 return;
238 238
239         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn); 239         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn);
240         pInfo->pPlugIn->StopDecodeFile(); 240         pInfo->pPlugIn->StopDecodeFile();
241 } 241 }
242 242
243 void CPlayer::PlugInClose() 243 void CPlayer::PlugInClose()
244 { 244 {
245         if (m_nFilePlugIn == -1) 245         if (m_nFilePlugIn == -1)
246                 return; 246                 return;
247 247
248         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn); 248         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn);
249         pInfo->pPlugIn->CloseFile(); 249         pInfo->pPlugIn->CloseFile();
250         m_nFilePlugIn = -1; 250         m_nFilePlugIn = -1;
251         m_nPlugInBps = 0; 251         m_nPlugInBps = 0;
252 } 252 }
253 253
254 void CPlayer::PlugInSetEqualizer() 254 void CPlayer::PlugInSetEqualizer()
255 { 255 {
-   256         int i;
256         PLUGIN_INFO* pInfo; 257         PLUGIN_INFO* pInfo;
257 258
258         MAP_PLUGIN_EQ eq; 259         MAP_PLUGIN_EQ eq;
259         eq.bEnable = m_Equalizer.fEnable; 260         eq.bEnable = m_Equalizer.fEnable;
260         eq.nPreamp = m_Equalizer.preamp; 261         eq.nPreamp = m_Equalizer.preamp;
261 262
262         for (int i = 0; i < 10; i++) -  
-   263         for (i = 0; i < 10; i++)
263                 eq.nEq[i] = m_Equalizer.data[i]; 264                 eq.nEq[i] = m_Equalizer.data[i];
264 265
265         int nCount = m_PlugInInfo.GetCount(); 266         int nCount = m_PlugInInfo.GetCount();
266         for (i = 0; i < nCount; i++) { 267         for (i = 0; i < nCount; i++) {
267                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i); 268                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i);
268 269
269                 if (pInfo->dwFunc & PLUGIN_FUNC_EQ) 270                 if (pInfo->dwFunc & PLUGIN_FUNC_EQ)
270                         pInfo->pPlugIn->SetEqualizer(&eq); 271                         pInfo->pPlugIn->SetEqualizer(&eq);
271         } 272         }
272 } 273 }
273 274
274 BOOL CPlayer::PlugInGetId3Tag(ID3TAGV1* pTag) 275 BOOL CPlayer::PlugInGetId3Tag(ID3TAGV1* pTag)
275 { 276 {
276         if (m_nFilePlugIn == -1) 277         if (m_nFilePlugIn == -1)
277                 return FALSE; 278                 return FALSE;
278 279
279         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn); 280         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nFilePlugIn);
280         if (pInfo->dwFunc & PLUGIN_FUNC_FILETAG) { 281         if (pInfo->dwFunc & PLUGIN_FUNC_FILETAG) {
281                 MAP_PLUGIN_FILETAG tag = {0}; 282                 MAP_PLUGIN_FILETAG tag = {0};
282                 BOOL fRet = pInfo->pPlugIn->GetTag(&tag); 283                 BOOL fRet = pInfo->pPlugIn->GetTag(&tag);
283 284
284                 pTag->nYear = tag.nYear; 285                 pTag->nYear = tag.nYear;
285                 pTag->nTrackNum = tag.nTrackNum; 286                 pTag->nTrackNum = tag.nTrackNum;
286                 _tcscpy(pTag->szGenre, tag.szGenre); 287                 _tcscpy(pTag->szGenre, tag.szGenre);
287                 _tcscpy(pTag->szAlbum, tag.szAlbum); 288                 _tcscpy(pTag->szAlbum, tag.szAlbum);
288                 _tcscpy(pTag->szArtist, tag.szArtist); 289                 _tcscpy(pTag->szArtist, tag.szArtist);
289                 _tcscpy(pTag->szComment, tag.szComment); 290                 _tcscpy(pTag->szComment, tag.szComment);
290                 _tcscpy(pTag->szTrack, tag.szTrack); 291                 _tcscpy(pTag->szTrack, tag.szTrack);
291 292
292                 return fRet; 293                 return fRet;
293         } 294         }
294 295
295         return FALSE; 296         return FALSE;
296 } 297 }
297 298
298 BOOL CPlayer::PlugInParseStream(LPBYTE pbBuf, DWORD cbBuf) 299 BOOL CPlayer::PlugInParseStream(LPBYTE pbBuf, DWORD cbBuf)
299 { 300 {
300         PLUGIN_INFO* pInfo; 301         PLUGIN_INFO* pInfo;
301         MAP_PLUGIN_STREMING_INFO info; 302         MAP_PLUGIN_STREMING_INFO info;
302         int nCount = m_PlugInInfo.GetCount(); 303         int nCount = m_PlugInInfo.GetCount();
303         for (int i = 0; i < nCount; i++) { 304         for (int i = 0; i < nCount; i++) {
304                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i); 305                 pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(i);
305                 if (pInfo->dwFunc & PLUGIN_FUNC_DECSTREAMING) { 306                 if (pInfo->dwFunc & PLUGIN_FUNC_DECSTREAMING) {
306                         if (pInfo->pPlugIn->OpenStreaming(pbBuf, cbBuf, &info)) { 307                         if (pInfo->pPlugIn->OpenStreaming(pbBuf, cbBuf, &info)) {
307                                 memset(&m_Info, 0, sizeof(m_Info)); 308                                 memset(&m_Info, 0, sizeof(m_Info));
308                                 m_Info.nChannels = info.nChannels; 309                                 m_Info.nChannels = info.nChannels;
309                                 m_Info.nSamplingRate = info.nSampleRate; 310                                 m_Info.nSamplingRate = info.nSampleRate;
310                                 m_Info.nBitRate = info.nAvgBitrate; 311                                 m_Info.nBitRate = info.nAvgBitrate;
311                                 m_nPlugInBps = info.nBitsPerSample; 312                                 m_nPlugInBps = info.nBitsPerSample;
312                                 m_Info.nFrameSize = 0; 313                                 m_Info.nFrameSize = 0;
313                                 m_Info.nSamplesPerFrame = 0; 314                                 m_Info.nSamplesPerFrame = 0;
314                                 315                                
315 316
316                                 m_nStreamingPlugIn = i; 317                                 m_nStreamingPlugIn = i;
317                                 return TRUE; 318                                 return TRUE;
318                         } 319                         }
319                 } 320                 }
320         } 321         }
321 322
322         return FALSE; 323         return FALSE;
323 } 324 }
324 325
325 void CPlayer::PlugInStreaming(LPBYTE pbBuf, DWORD cbBuf) 326 void CPlayer::PlugInStreaming(LPBYTE pbBuf, DWORD cbBuf)
326 { 327 {
327         DWORD cbInBuf, cbInBufLeft = 0; 328         DWORD cbInBuf, cbInBufLeft = 0;
328         cbInBuf = cbBuf; 329         cbInBuf = cbBuf;
329 330
330         int nRet; 331         int nRet;
331         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nStreamingPlugIn); 332         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nStreamingPlugIn);
332         while (TRUE) { 333         while (TRUE) {
333                 if (m_fStop) { 334                 if (m_fStop) {
334                         UnpreparePlayback(); 335                         UnpreparePlayback();
335                         return; 336                         return;
336                 } 337                 }
337 338
338                 if (m_Receiver.GetBufferingCount() < 2) { 339                 if (m_Receiver.GetBufferingCount() < 2) {
339                         while (TRUE) { 340                         while (TRUE) {
340                                 Sleep(1); 341                                 Sleep(1);
341                                 if (m_Output.GetBufferingCount() < 1) 342                                 if (m_Output.GetBufferingCount() < 1)
342                                         break; 343                                         break;
343                                 if (m_Receiver.GetBufferingCount() > 1) 344                                 if (m_Receiver.GetBufferingCount() > 1)
344                                         goto read; 345                                         goto read;
345                                 if (m_fStop) { 346                                 if (m_fStop) {
346                                         UnpreparePlayback(); 347                                         UnpreparePlayback();
347                                         return; 348                                         return;
348                                 } 349                                 }
349                         } 350                         }
350 351
351                         if (!NetReconnect()) 352                         if (!NetReconnect())
352                                 return; 353                                 return;
353 354
354                         m_Output.Pause(TRUE); 355                         m_Output.Pause(TRUE);
355                         m_fPlay = TRUE; 356                         m_fPlay = TRUE;
356                 } 357                 }
357 358
358 read: 359 read:
359                 if (!m_Receiver.Read(pbBuf + cbInBufLeft, NET_READ_BUFF_LEN - cbInBufLeft, &cbInBuf) || !cbInBuf) { 360                 if (!m_Receiver.Read(pbBuf + cbInBufLeft, NET_READ_BUFF_LEN - cbInBufLeft, &cbInBuf) || !cbInBuf) {
360                         UnpreparePlayback(TRUE); 361                         UnpreparePlayback(TRUE);
361                         return; 362                         return;
362                 } 363                 }
363 364
364                 cbInBufLeft += cbInBuf; 365                 cbInBufLeft += cbInBuf;
365                 cbInBuf = 0; 366                 cbInBuf = 0;
366 367
367                 if (!m_pOutHdr) { 368                 if (!m_pOutHdr) {
368                         m_pOutHdr = m_Output.GetBuffer(); 369                         m_pOutHdr = m_Output.GetBuffer();
369                         m_cbOutBufLeft = m_cbOutBuf; 370                         m_cbOutBufLeft = m_cbOutBuf;
370                 } 371                 }
371 372
372                 m_pOutHdr->dwBytesRecorded = 0; 373                 m_pOutHdr->dwBytesRecorded = 0;
373                 m_pOutHdr->dwBufferLength = m_cbOutBuf; 374                 m_pOutHdr->dwBufferLength = m_cbOutBuf;
374                 nRet = pInfo->pPlugIn->DecodeStreaming(pbBuf, cbInBufLeft, &cbInBuf, m_pOutHdr); 375                 nRet = pInfo->pPlugIn->DecodeStreaming(pbBuf, cbInBufLeft, &cbInBuf, m_pOutHdr);
375                 if (nRet == PLUGIN_RET_ERROR) { 376                 if (nRet == PLUGIN_RET_ERROR) {
376                         UnpreparePlayback(FALSE, TRUE); 377                         UnpreparePlayback(FALSE, TRUE);
377                         break; 378                         break;
378                 } 379                 }
379 380
380                 if (m_pOutHdr->dwBytesRecorded) { 381                 if (m_pOutHdr->dwBytesRecorded) {
381                         if (!(pInfo->dwFunc & PLUGIN_FUNC_EQ)) 382                         if (!(pInfo->dwFunc & PLUGIN_FUNC_EQ))
382                                 Preamp((LPBYTE)m_pOutHdr->lpData, m_pOutHdr->dwBytesRecorded); 383                                 Preamp((LPBYTE)m_pOutHdr->lpData, m_pOutHdr->dwBytesRecorded);
383                         OutputBuffer(m_pOutHdr, m_pOutHdr->dwBytesRecorded); 384                         OutputBuffer(m_pOutHdr, m_pOutHdr->dwBytesRecorded);
384                         m_pOutHdr = NULL; 385                         m_pOutHdr = NULL;
385                 } 386                 }
386 387
387                 if (nRet == PLUGIN_RET_EOF) { 388                 if (nRet == PLUGIN_RET_EOF) {
388                         UnpreparePlayback(TRUE); 389                         UnpreparePlayback(TRUE);
389                         break; 390                         break;
390                 } 391                 }
391 392
392                 memmove(pbBuf, pbBuf + cbInBuf, cbInBufLeft - cbInBuf); 393                 memmove(pbBuf, pbBuf + cbInBuf, cbInBufLeft - cbInBuf);
393                 cbInBufLeft -= cbInBuf; 394                 cbInBufLeft -= cbInBuf;
394         } 395         }
395 } 396 }
396 397
397 void CPlayer::PlugInStopStreaming() 398 void CPlayer::PlugInStopStreaming()
398 { 399 {
399         if (m_nStreamingPlugIn == -1) 400         if (m_nStreamingPlugIn == -1)
400                 return; 401                 return;
401 402
402         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nStreamingPlugIn); 403         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(m_nStreamingPlugIn);
403         pInfo->pPlugIn->CloseStreaming(); 404         pInfo->pPlugIn->CloseStreaming();
404         m_nStreamingPlugIn = -1; 405         m_nStreamingPlugIn = -1;
405         m_nPlugInBps = 0; 406         m_nPlugInBps = 0;
406 } 407 }
407 408
408 int CPlayer::PlugInGetCount() 409 int CPlayer::PlugInGetCount()
409 { 410 {
410         return m_PlugInInfo.GetCount(); 411         return m_PlugInInfo.GetCount();
411 } 412 }
412 413
413 MAP_DEC_PLUGIN* CPlayer::PlugInGetInterface(int nPlugIn) 414 MAP_DEC_PLUGIN* CPlayer::PlugInGetInterface(int nPlugIn)
414 { 415 {
415         if (nPlugIn >= PlugInGetCount()) 416         if (nPlugIn >= PlugInGetCount())
416                 return NULL; 417                 return NULL;
417 418
418         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(nPlugIn); 419         PLUGIN_INFO* pInfo = (PLUGIN_INFO*)m_PlugInInfo.GetAt(nPlugIn);
419         return pInfo->pPlugIn; 420         return pInfo->pPlugIn;
420 } 421 }