rtoss - Blame information for rev 26

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