开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
mp3.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：22k
源码类别：

多媒体编程

开发平台：

Visual C++

mp3.c：源码内容
  1. /*  @(#) mp3.c, last edit: 4/9/1998
  2.  *  @(#) Copyright (C) 1998 Syntrillium Software (www.syntrillium.com)
  3.  
  4. Cool Edit (and Cool Edit Pro) MP3 file reader based on MAPLAY by Jeff Tsay
  6. A bunch of convoluted code was added to this file filter in order to allow
  7. for the choice of volume level during decode, and format to decode to. 
  8. That's right, you can decode to 16-bit by truncation, or by dithering, or
  9. keep an entire 32-bit float for each sample for use in Cool Edit Pro.
  11.     Versions Cool Edit that do not support 32-bit will still say "32-bit" when
  12. the file is loaded, but rest assured, it's only 16-bit.
  14. Most of the files for MAPLAY were left untouched, and many were not needed
  15. for this port, so only the files needed for the port are included here.
  17.     Search for MAPLAY 1.2 or later for original source (and if the source gets
  18. updated, it should be trivial to add it to this build).  Very few of the 
  19. other files were modified, and when they were, they were bracketed by 
  20. "#ifdef COOLPRO" for easy location and such.
  22. The Obuffer class was modified to take in floats instead of ints for
  23. reading in with greater accuracy.  Since MPEG (which is similar to JPEG
  24. in this respect) doesn't try to encode the exact sample values, but 
  25. instead is psychoacoustic in nature, higher quality can be gained by
  26. encoding from a 32-bit source (I haven't found an encoder that can take
  27. floating point samples yet) and then decoding back to 32-bit.  Nothing
  28. in MPEG says it should be limited to 16-bit I believe (but don't quote
  29. me on this... I do not know much about the internals of the MPEG format).
  31. Some links to the binaries of ports of maplay are on Jeff's homepage at:
  32. http://www-inst.eecs.berkeley.edu/~ctsay/mp2win32.html
  35.   Believe it or not, the speed is much faster than original ISO MPEG code,
  36.   but still slower than Fraunhoffer.  Their Windows ACM codec is about
  37.   twice as fast for reading.  But the good news is it that it's still fast
  38.   enough for real time previewing (auto-play) on pretty much all Pentiums.
  40.   If you purchase an ACM codec for writing Layer 3 MPEG, use the updated
  41.   ACM Waveform format type found at http://www.syntrillium.com which allows
  42.   for saving any ACM format as raw data thus allowing the saving directly
  43.   to .mp3 files if you have the codec which can write MPEG .wav files.
  46.  *
  47.  *  This program is free software; you can redistribute it and/or modify
  48.  *  it under the terms of the GNU General Public License as published by
  49.  *  the Free Software Foundation; either version 2 of the License, or
  50.  *  (at your option) any later version.
  51.  *
  52.  *  This program is distributed in the hope that it will be useful,
  53.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  54.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  55.  *  GNU General Public License for more details.
  56.  *
  57.  *  You should have received a copy of the GNU General Public License
  58.  *  along with this program; if not, write to the Free Software
  59.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  60.  *
  63. */
  66. #include <windows.h>
  67. #include <math.h>
  68. #include "filters.h"
  69. #include "ceglue.h"
  70. #include "resource.h"
  73. // Hey!  Someone want a _real_ challenge?  Implement Layer 3 encoding as well!
  74.     
  75. typedef struct output_tag  // any special vars associated with output file
  76. { short nFile;         
  77. long lSize;
  78. } MYOUTPUT;
  80. typedef struct input_tag // any special vars associated with input file
  81. { short nFile;
  82. long lSize;
  83. long lSamprate;
  84. DWORD dwFormat;
  85. BOOL bOpenedMPEG;
  86. MPEG_INFO mpi;
  87. double fAttenuation;
  88. float fScaleBy;
  89. WORD wBitsPerSample;
  90. BOOL bDither;
  91. HANDLE h32bit;
  92. short * pi32bit;
  93. } MYINPUT;
  95. HANDLE myInstance=NULL;
  97. BOOL WINAPI DllMain (HANDLE hModule, DWORD fdwReason, LPVOID lpReserved)
  98. {
  99.    switch (fdwReason)
  100.    {
  101.       case DLL_PROCESS_ATTACH:
  102.         
  103.  myInstance=hModule;
  104.     
  105.          break;
  106.  
  107.       case DLL_THREAD_ATTACH:
  108.          break;
  109.  
  110.       case DLL_THREAD_DETACH:
  111.          break;
  112.  
  113.       case DLL_PROCESS_DETACH:
  114.          myInstance=NULL;
  115.          break;
  116.    }
  117.  
  118.    return TRUE;   
  119. }
  121. // Fill COOLQUERY structure with information regarding this file filter
  123. __declspec(dllexport) short FAR PASCAL QueryCoolFilter(COOLQUERY far * cq)
  124. {   lstrcpy(cq->szName,"MPEG 3");         
  125. lstrcpy(cq->szCopyright,"MPEG (Layer 1,2,3) Decoder (GNU)");
  126. lstrcpy(cq->szExt,"MP3");
  127. lstrcpy(cq->szExt2,"MP2");
  128. lstrcpy(cq->szExt3,"MP1");
  129. cq->lChunkSize=16384; 
  130. cq->dwFlags=QF_RATEADJUSTABLE|QF_CANLOAD|QF_CANDO32BITFLOATS|QF_HASOPTIONSBOX;
  131. cq->Stereo8=0; 
  132. cq->Stereo16=R_32075|R_44100|R_48000;
  133. cq->Stereo24=0;
  134. cq->Stereo32=R_32075|R_44100|R_48000;
  135. cq->Mono8=0; 
  136. cq->Mono16=R_32075|R_44100|R_48000;
  137. cq->Mono24=0;
  138. cq->Mono32=R_32075|R_44100|R_48000;
  139. cq->Quad32=0;
  140. cq->Quad16=0;
  141. cq->Quad8=0;
  142. return C_VALIDLIBRARY;
  143. }
  145. // Just our little way of not including stdio.h to do float to string cvting
  146. char * ftos(char *tmp, double d)
  147. { double dd;
  148. double mplier;
  149. short maxdecimal=9;
  150. char * otemp;
  152. otemp=tmp;
  154. if (d==0)
  155. { *tmp='0';
  156.   tmp++;
  157.   *tmp=0x00;
  158.   return otemp;
  159. } 
  161. if (d<0)
  162. { *tmp='-';
  163. tmp++;
  164. d=-d;
  165. }
  166. d=d+(1.0/65535.0/32768.0);
  167. dd=d;         
  168. mplier=1.0;
  169. while (dd>=1.0)
  170. { dd/=10.0;
  171. mplier*=10.0;
  172. }   
  173. mplier/=10.0;             
  174. while (mplier>=1.0)
  175. { *tmp='0'+(short)(d/mplier);
  176. tmp++;
  177. d=d-mplier*(short)(d/mplier);
  178. mplier/=10.0;
  179. }
  180.     if (d!=0.0)
  181.     { short digit;
  182.      *tmp='.';
  183.      tmp++;
  184.      while ((d!=0.0) && (maxdecimal!=0))
  185.      { d*=10.0;
  186.      digit=(short)d;
  187.      d-=(double)digit;
  188.      *tmp='0'+digit;
  189.      tmp++;
  190.      maxdecimal--;         
  191.      }             
  192.      while (*(tmp-1)=='0')
  193.      tmp--;
  194.      if (*(tmp-1)=='.')
  195.      tmp--;
  196.     }
  197.                   
  198.     *tmp=0x00;   
  199.     
  200.     return otemp;
  201. }                                  
  203. __declspec(dllexport) long FAR PASCAL FilterGetFileSize(HANDLE hInput)
  204. {
  205. long lSize=0L;
  206. if (hInput)
  207. {       MYINPUT *mi;
  208. mi=(MYINPUT *)GlobalLock(hInput);
  209. lSize=mi->lSize;
  210. GlobalUnlock(hInput);
  211. }
  212.     return lSize;
  213. }
  215. __declspec(dllexport) BOOL FAR PASCAL FilterGetActualFormat(HANDLE hInput,DWORD dwOptions,long * plSamprate, WORD * pwChannels, WORD * pwBitsPerSample)
  216. {   
  217. if (hInput)
  218. { MYINPUT *mi;
  219. mi=(MYINPUT *)GlobalLock(hInput);
  221. *pwBitsPerSample=HIWORD(dwOptions)&0x00FF;
  223. GlobalUnlock(hInput);
  224. }
  225.     return TRUE;
  226. }
  229. __declspec(dllexport) BOOL FAR PASCAL FilterUnderstandsFormat(LPSTR filename)
  230. {
  231. if ((lstrlen(filename)>4) && 
  232. ((strcmpi(filename+lstrlen(filename)-4,".mp3")==0) ||
  233.  (strcmpi(filename+lstrlen(filename)-4,".mp2")==0) ||
  234.  (strcmpi(filename+lstrlen(filename)-4,".mp1")==0)  
  235.  ))
  236. {
  237.    return TRUE;
  238.    }
  239.    return FALSE;
  240. }
  243. __declspec(dllexport) BOOL FAR PASCAL DIALOGMsgProc(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam)
  244. { switch(Message)
  245. { case WM_INITDIALOG:
  246. {  WORD wBitsPerSample;
  247.  double fAttenuation;
  248.  BOOL bDither;
  249.  char tmp[30];
  251.            wBitsPerSample=HIWORD(lParam)&0x00FF;
  252.  bDither=(lParam&0x01000000)?TRUE:FALSE;
  253.  fAttenuation=(double)((DWORD)lParam&0xffff)/100.0-200.0;
  254.              if (fAttenuation>200.0)
  255.  fAttenuation=0.0;
  257.  //wsprintf(tmp," Read MPEG As %d-bit ",wBitsPerSample);
  258.  //SetDlgItemText(hWndDlg,IDC_TEXT1,tmp);
  259.              
  260.  if (wBitsPerSample==16)
  261.          { CheckDlgButton(hWndDlg,IDC_RADIO1,TRUE);
  262.          }
  263.          else if (wBitsPerSample==32)
  264.          {  CheckDlgButton(hWndDlg,IDC_RADIO2,TRUE);
  265.          }
  266.          else
  267.          { CheckDlgButton(hWndDlg,IDC_RADIO1,TRUE);
  268.          }
  269.  
  270.  CheckDlgButton(hWndDlg,IDC_CHECK1,bDither);
  271.          ftos(tmp,fAttenuation);
  272.  SetDlgItemText(hWndDlg,IDC_EDIT1,tmp);
  273.  EnableWindow(GetDlgItem(hWndDlg,IDC_CHECK1),IsDlgButtonChecked(hWndDlg,IDC_RADIO1)?TRUE:FALSE);
  274.          }         
  275.          break; 
  277. case WM_CLOSE:         
  278.  PostMessage(hWndDlg, WM_COMMAND, IDCANCEL, 0L);
  279.  break; 
  281. case WM_COMMAND:
  282. { WORD wNotifyCode=HIWORD(wParam);
  283. wParam=(WPARAM)LOWORD(wParam);
  284. switch(wParam)
  285. {
  286. case IDC_RADIO1:
  287. case IDC_RADIO2:
  288. EnableWindow(GetDlgItem(hWndDlg,IDC_CHECK1),IsDlgButtonChecked(hWndDlg,IDC_RADIO1)?TRUE:FALSE);
  289. break;
  291. case IDOK:
  292. { long nDialogReturn=0;
  293.              char tmp[30];
  295. if (IsDlgButtonChecked(hWndDlg,IDC_RADIO2))
  296. { nDialogReturn=32L<<16;
  297. }
  298. else
  299. { nDialogReturn=16L<<16;
  300. }
  302. GetDlgItemText(hWndDlg,IDC_EDIT1,tmp,29);
  303. nDialogReturn|=(WORD)max(0,min(40000,(atof(tmp)+200.0)*100.0));
  304. if (IsDlgButtonChecked(hWndDlg,IDC_CHECK1))
  305. nDialogReturn|=0x01000000;
  307. EndDialog(hWndDlg, nDialogReturn);
  308. }
  309. break;
  311. case IDCANCEL:
  312.  EndDialog(hWndDlg, FALSE);
  313.  break;
  314. }
  315. break;
  316. }
  317. default:
  318. return FALSE;
  319. }
  320. return TRUE;
  321. } 
  323. __declspec(dllexport) DWORD FAR PASCAL FilterGetOptions(HWND hWnd, HINSTANCE hInst, long lSamprate, WORD wChannels, WORD wBitsPerSample, DWORD dwOptions) // return 0 if no options box
  324. {
  325. long nDialogReturn=0L;
  326. FARPROC lpfnDIALOGMsgProc;
  327. lpfnDIALOGMsgProc = GetProcAddress(hInst,(LPCSTR)MAKELONG(20,0));
  329. if (dwOptions==0)
  330. {
  331. nDialogReturn=GetPrivateProfileInt("MPEG Filter","InputFormat",0,"coolrw.ini");
  332. if (nDialogReturn==0)
  333. nDialogReturn=(WORD)max(0,min(40000,(100.0+200.0)*100.0));
  334. }
  335. else
  336. nDialogReturn=dwOptions;
  338. // These were to force the dialog to have _only_ 16 or 32... now we let user choose
  339. //nDialogReturn=(nDialogReturn&0xFF00FFFF)|(((DWORD)wBitsPerSample)<<8);
  340. //nDialogReturn|=MAKELONG(nDialogReturn&0x0FF,wBitsPerSample);
  342. nDialogReturn = (long)DialogBoxParam((HINSTANCE)hInst,(LPCSTR)MAKEINTRESOURCE(IDD_COMPRESSION), (HWND)hWnd, (DLGPROC)lpfnDIALOGMsgProc,nDialogReturn);
  344. if (nDialogReturn)
  345. { char m[30];
  346. wsprintf(m,"%d",nDialogReturn);
  347. WritePrivateProfileString("MPEG Filter","InputFormat",m,"coolrw.ini");
  348. }
  350. return nDialogReturn;
  351. }          
  353. __declspec(dllexport) DWORD FAR PASCAL FilterSetOptions2(HANDLE hInput, DWORD dwOptions, long * plSamprate, WORD * pwChannels, WORD * pwBitsPerSample)
  354. {
  355. DWORD dwOldOptions;
  356. MYINPUT *mi;
  357. mi=(MYINPUT *)GlobalLock(hInput);
  359. dwOldOptions=mi->dwFormat;
  361. if (!dwOptions)
  362. { dwOptions=(DWORD)GetPrivateProfileInt("MPEG Filter","InputFormat",0,"coolrw.ini");
  363. if (!dwOptions)
  364. dwOptions=(WORD)max(0,min(40000,(200.0)*100.0))|(16L<<16);
  365. }
  367. mi->wBitsPerSample=HIWORD(dwOptions)&0x00FF;
  368. mi->fAttenuation=(double)((DWORD)dwOptions&0xffff)/100.0-200.0;
  369. mi->bDither=(dwOptions&0x01000000)?TRUE:FALSE;
  371.     mi->dwFormat=dwOptions;
  373. if ((mi->fAttenuation<-199.0) || (mi->fAttenuation>200.0))
  374. mi->fAttenuation=0;
  376. if (mi->wBitsPerSample==16)
  377. { *pwBitsPerSample=16;
  378. if (!mi->h32bit)
  379. { mi->h32bit=GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,32768);
  380. mi->pi32bit=(short *)GlobalLock(mi->h32bit);
  381. }
  382. }
  383. else
  384. { *pwBitsPerSample=32;
  385. }
  386. mi->lSize=(int)(mi->mpi.fLengthInMilliseconds*(*plSamprate)/1000.0)*(*pwChannels)*(*pwBitsPerSample/8);
  387. mi->fScaleBy=(float)(32768.0*(pow(10.0,mi->fAttenuation/20.0)));
  389.     GlobalUnlock(hInput);
  390.     
  391.     return dwOldOptions;
  392.         
  393. }
  395. // Dummy, but must be here... FilterSetOptions2 is actually called instead if it exists
  396. __declspec(dllexport) DWORD FAR PASCAL FilterSetOptions(HANDLE hInput, DWORD dwOptions, long lSamprate, WORD wChannels, WORD wBitsPerSample)
  397. {
  398. DWORD dwOldOptions;
  399. MYINPUT *mi;
  400. mi=(MYINPUT *)GlobalLock(hInput);
  402. dwOldOptions=mi->dwFormat;
  404.     mi->dwFormat=dwOptions;
  405. mi->wBitsPerSample=HIWORD(dwOptions)&0x00FF;
  406. mi->fAttenuation=(double)((DWORD)dwOptions&0xffff)/100.0-200.0;
  407. mi->bDither=(dwOptions&0x01000000)?TRUE:FALSE;
  409. if ((mi->fAttenuation<-199.0) || (mi->fAttenuation>200.0))
  410. mi->fAttenuation=0;
  412. if (mi->wBitsPerSample==16)
  413. { if (!mi->h32bit)
  414. { mi->h32bit=GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,32768);
  415. mi->pi32bit=(short *)GlobalLock(mi->h32bit);
  416. }
  417. }
  419. mi->lSize=(int)(mi->mpi.fLengthInMilliseconds*(lSamprate)/1000.0)*(wChannels)*(wBitsPerSample/8);
  420. mi->fScaleBy=(float)(32768.0*(pow(10.0,mi->fAttenuation/20.0)));
  422.     GlobalUnlock(hInput);
  423.     
  424.     return dwOldOptions;
  425. }
  428. __declspec(dllexport) DWORD FAR PASCAL FilterOptions(HANDLE hInput)
  429. {   MYINPUT *mi;
  430. DWORD dwFormat;
  431. if (!hInput) return 0;
  432. mi=(MYINPUT *)GlobalLock(hInput);
  434. dwFormat=(DWORD)mi->dwFormat;
  436.     GlobalUnlock(hInput);
  437.     return dwFormat;
  438. }
  441. __declspec(dllexport) DWORD FAR PASCAL FilterOptionsString(HANDLE hInput, LPSTR szString)
  442. {   MYINPUT *mi;
  443. DWORD dwFormat;
  445. if (!hInput) return 0;
  446. mi=(MYINPUT *)GlobalLock(hInput);
  447.     dwFormat=(DWORD)mi->dwFormat;
  449. wsprintf(szString,"%s Layer %drn(%s)",mi->mpi.szVersion,mi->mpi.iLayer,mi->mpi.szBitrate);
  451.     GlobalUnlock(hInput);
  452.     return dwFormat;
  453. }
  456. __declspec(dllexport) DWORD FAR PASCAL FilterCanWriteSpecial(HANDLE hOutput, DWORD idType)
  457. {
  458.  return 0L;
  459. }
  461. __declspec(dllexport) DWORD FAR PASCAL FilterCanReadSpecial(HANDLE hInput, DWORD idType)
  462. {
  463.  return 0L;
  464. }
  465.  
  466. __declspec(dllexport) DWORD FAR PASCAL FilterWriteSpecial(HANDLE hOutput, DWORD idType, unsigned char far *buf, DWORD dwSize)
  467. {
  468.  return 0L;
  469. }
  471. __declspec(dllexport) DWORD FAR PASCAL FilterReadSpecial(HANDLE hOutput, DWORD idType, unsigned char far *buf, DWORD dwSize)
  472. {
  473.  return 0L;
  474. }
  478. __declspec(dllexport) HANDLE FAR PASCAL OpenFilterOutput(LPSTR lpstrFilename,long lSamprate,WORD wBitsPerSample,WORD wChannels,long lSize,long far *lpChunkSize,DWORD dwOptions)
  479. {   HANDLE hOutput;
  480. short nFile;
  481. nFile=_lcreat(lpstrFilename,0);
  482.     if (nFile==-1) return NULL;
  483.     hOutput=GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE,sizeof(MYOUTPUT));
  484.     if (hOutput)
  485.     {   MYOUTPUT *mo;
  486. mo=(MYOUTPUT *)GlobalLock(hOutput);
  487. mo->nFile=nFile;
  488. mo->lSize=lSize;
  489. GlobalUnlock(hOutput);
  490.     }
  491.     *lpChunkSize=16384;
  492.     return hOutput;
  493. }
  495. __declspec(dllexport) void FAR PASCAL CloseFilterOutput(HANDLE hOutput)
  496. {   if (hOutput)
  497. {       MYOUTPUT *mo;
  498. mo=(MYOUTPUT *)GlobalLock(hOutput);
  499. if (mo->nFile!=-1)
  500. {       _lclose(mo->nFile);
  501. mo->nFile=-1;
  502. }
  504. GlobalUnlock(hOutput);
  505. GlobalFree(hOutput);
  506. }
  507. }
  509. __declspec(dllexport) DWORD FAR PASCAL WriteFilterOutput(HANDLE hOutput, unsigned char far *buf, long lBytes)
  510. {       DWORD written=0L;
  511. if (hOutput)
  512. {       MYOUTPUT *mo;
  513. mo=(MYOUTPUT *)GlobalLock(hOutput);
  514. written=(DWORD)_lwrite(mo->nFile,buf,(UINT)lBytes);
  515. GlobalUnlock(hOutput);
  516. }
  517. return written; 
  518. }
  520. DWORD valJ=524309;
  521. DWORD valI=12345; // reset to time at startup
  523. double fRandom(void) // 0 to 1
  524. { DWORDLONG dwl;
  525. dwl=UInt32x32To64(valJ,valI);
  526. dwl++;
  527. valI=(DWORD)(dwl&0x1FFFFF);
  528. return (double)valI/2097152.0;
  529. }
  531. // This is the 32-bit to 16-bit converter from Cool Edit, but with only the code
  532. // for the straight triangular dithering.  For higher quality, read in the file
  533. // as 32-bit, then use Cool Edit Pro's dithering options for going to 16-bit.
  535. void HfCvt32To16InMem(short *piDest, float *pfSource, long dwSourceSamples, BOOL bStereo, double fDitherAmount)
  536. { long t;
  537. double fFilteredError=0;
  538. double fSourceBeforeNoise;
  539. double qq=1.0;
  540. double fMultiplier=0.5;
  541. double fNoise;
  542. double fSource;
  543. double fSqrtDitherAmount;
  544. long quant;
  545. static double fError=0;
  546. static double fError1=0;
  547. static double fError2=0;
  548. static double fError3=0;
  549. static double fError4=0;
  550. static double fError5=0;
  551. static double fErrorR=0;
  552. static double fErrorR1=0;
  553. static double fErrorR2=0;
  554. static double fErrorR3=0;
  555. static double fErrorR4=0;
  556. static double fErrorR5=0;
  557.     
  558. {   
  559. if (fDitherAmount>0)
  560. fSqrtDitherAmount=sqrt(fDitherAmount);
  561. else
  562. fSqrtDitherAmount=0;
  564. if (bStereo)
  565.   {
  566. for (t=0;t<dwSourceSamples;t+=2)
  567. {
  568. fFilteredError=0;
  570. fError4=fError3;
  571. fError3=fError2;
  572. fError2=fError1;
  573. fError1=fFilteredError;
  575. fSource=*pfSource;
  576. pfSource++;
  578. // Don't Shift out 8 bits
  579. fSource=fSource-fFilteredError; //*fDitherMultiplier;
  581. fNoise=fDitherAmount*(fRandom()+fRandom()-1.0);
  583. fSourceBeforeNoise=fSource;
  585. // Add Noise (v)
  586. fSource+=fNoise; //*fDitherMultiplier; //*2.0;
  588. // Quantization
  589. quant=(long)(fSource+500000+0.5)-500000; // floor function, values -1000 to +1000 OK
  591. // Error for input to H(z)
  592. fError=(double)quant-fSourceBeforeNoise;
  594. if (quant>=-32768)
  595. { if (quant<=32767)
  596. *piDest=(short)quant;
  597. else
  598. *piDest=32767;
  599. }
  600. else
  601. *piDest=-32768;
  602. piDest++;
  604. fFilteredError=0;
  606. fErrorR4=fErrorR3;
  607. fErrorR3=fErrorR2;
  608. fErrorR2=fErrorR1;
  609. fErrorR1=fFilteredError;
  611. fSource=*pfSource;
  612. pfSource++;
  614. // Don't Shift out 8 bits
  615. fSource=fSource-fFilteredError; //*fDitherMultiplier;
  617. fNoise=fDitherAmount*(fRandom()+fRandom()-1.0);
  619. fSourceBeforeNoise=fSource;
  621. // Add Noise (v)
  622. fSource+=fNoise; //*fDitherMultiplier; //*2.0;
  624. // Quantization
  625. quant=(long)(fSource+500000+0.5)-500000; // floor function, values -1000 to +1000 OK
  627. // Error for input to H(z)
  628. fErrorR=(double)quant-fSourceBeforeNoise;
  630. if (quant>=-32768)
  631. { if (quant<=32767)
  632. *piDest=(short)quant;
  633. else
  634. *piDest=32767;
  635. }
  636. else
  637. *piDest=-32768;
  638. piDest++;
  639. }
  640.   }       
  641.   else
  642.   {   
  643. for (t=0;t<dwSourceSamples;t++)
  644. { fFilteredError=0;
  646. fError5=fError4;
  647. fError4=fError3;
  648. fError3=fError2;
  649. fError2=fError1;
  650. fError1=fFilteredError;
  652. fSource=*pfSource;
  653. pfSource++;
  655. // Don't Shift out 8 bits
  656. fSource=fSource-fFilteredError; //*fDitherMultiplier;
  657. // Triangular Dither Noise
  659. fNoise=fDitherAmount*(fRandom()+fRandom()-1.0);
  661. fSourceBeforeNoise=fSource;
  663. // Add Noise (v)
  664. fSource+=fNoise; //*fDitherMultiplier; //*2.0;
  666. // Quantization
  667. quant=(long)(fSource+500000+0.5)-500000; // floor function, values -1000 to +1000 OK
  669. // Error for input to H(z)
  670. fError=(double)quant-fSourceBeforeNoise;
  672. if (quant>=-32768)
  673. { if (quant<=32767)
  674. *piDest=(short)quant;
  675. else
  676. *piDest=32767;
  677. }
  678. else
  679. *piDest=-32768;
  680. piDest++;
  682. }
  683. } 
  684. }
  685. }
  688. __declspec(dllexport) void FAR PASCAL GetSuggestedSampleType(long far *lSugSamprate,WORD far *wSugBitsPerSample, WORD far *wSugChannels)
  689. {   // return 0 for don't care
  690.   *lSugSamprate=0;
  691. { int n=GetPrivateProfileInt("MPEG Filter","InputFormat",0,"coolrw.ini");
  692. *wSugBitsPerSample=HIWORD(n)&0x00FF;
  693. if ((*wSugBitsPerSample!=16) && (*wSugBitsPerSample!=32))
  694. *wSugBitsPerSample=16;
  695. }
  696.   *wSugChannels=0;
  697. }
  700. // return handle that will be passed in to close, and write routines
  701. __declspec(dllexport) HANDLE FAR PASCAL OpenFilterInput( LPSTR lpstrFilename,
  702. long *lSamprate,
  703. WORD *wBitsPerSample,
  704. WORD *wChannels,
  705. HWND hWnd,
  706. long *lChunkSize)
  707. { HANDLE hInput;
  708. short source; 
  709. long fullsize;
  710. DWORD dwOptions;
  712. dwOptions=0;
  713. valI=GetTickCount()%50000;
  715. source=_lopen(lpstrFilename,OF_READ);
  716.     if (source==-1) return NULL;     
  717.     
  718.     fullsize=_llseek(source,0L,2);
  719. _lclose(source);
  721.     hInput=GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT,sizeof(MYINPUT));
  722.     if (hInput)
  723.     {   MYINPUT *mi;
  725. mi=(MYINPUT *)GlobalLock(hInput);
  727. mi->wBitsPerSample=32; 
  728. mi->fAttenuation=0; 
  729. mi->dwFormat=0; // Force asking of format, and default to 32-bit No attenuation
  730. mi->fScaleBy=32768.0f;
  731. mi->bDither=FALSE;
  733. // return 0 for cool to inquire user for sample rates (we aren't doing that though)
  734. *lSamprate=44100;
  735. *wBitsPerSample=32;
  736. *wChannels=2;
  737. *lChunkSize=16384;
  739. mi->bOpenedMPEG=MPEG_Open(lpstrFilename);
  740. if (!mi->bOpenedMPEG)
  741. { GlobalUnlock(hInput);
  742.       GlobalFree(hInput);
  743.       return NULL;
  744. }
  746. MPEG_GetInfo(&mi->mpi);
  748. *lSamprate=mi->mpi.iSamplerate;
  749. *wChannels=mi->mpi.iChannels;
  751. { int n=GetPrivateProfileInt("MPEG Filter","InputFormat",0,"coolrw.ini");
  752. *wBitsPerSample=HIWORD(n)&0x00FF;
  753. if ((*wBitsPerSample!=16) && (*wBitsPerSample!=32))
  754. *wBitsPerSample=16;
  755. }
  757. mi->wBitsPerSample=*wBitsPerSample;
  759. mi->lSize=(int)(mi->mpi.fLengthInMilliseconds*(*lSamprate)/1000.0)*(*wChannels)*(*wBitsPerSample/8);
  761. GlobalUnlock(hInput);
  762.     }
  763.     
  764.     return hInput;
  765. }
  767. __declspec(dllexport) void FAR PASCAL CloseFilterInput(HANDLE hInput)
  768. {   if (hInput)  
  769. {       MYINPUT *mi;
  770. mi=(MYINPUT *)GlobalLock(hInput);
  772. if (mi->bOpenedMPEG)
  773. MPEG_Close();
  774.     
  775. if (mi->h32bit)
  776. { GlobalUnlock(mi->h32bit);
  777. GlobalFree(mi->h32bit);
  778. }
  780. GlobalUnlock(hInput);
  781. GlobalFree(hInput);
  782. }
  783. }
  787. __declspec(dllexport) DWORD FAR PASCAL ReadFilterInput(HANDLE hInput, unsigned char far *bufout, long lBytes)
  788. {       DWORD read=0L;
  789. if (hInput)
  790. {   MYINPUT *mi;
  791. float fScaleBy;
  793. mi=(MYINPUT *)GlobalLock(hInput);
  794. fScaleBy=mi->fScaleBy;
  796. if (mi->wBitsPerSample==32)
  797. { // just scale
  798. read=(DWORD)MPEG_Read(bufout);
  800. { int iNum=read/4;
  801. float * pBuf=(float *)bufout;
  802. while (iNum--)
  803. { *pBuf++*=fScaleBy;
  804. }
  805. }
  807. }
  808. else if (mi->wBitsPerSample==16)
  809. { // Convert to 16-bit with scaling and dithering
  810. int iNum;
  811. float * pfBuf;
  812. short * piBuf;
  814. pfBuf=(float *)mi->pi32bit;
  815. piBuf=(short *)bufout;
  817. read=(DWORD)MPEG_Read((BYTE *)mi->pi32bit);
  818. iNum=read/4;
  819. // Dither it to 16-bit
  821. if (mi->bDither)
  822. { // Scale it first
  823. { int iNum=read/4;
  824. float * pBuf=pfBuf;
  825. while (iNum--)
  826. { *pBuf++*=fScaleBy;
  827. }
  828. }
  830. // Dither and Clip
  831. HfCvt32To16InMem(piBuf, pfBuf, iNum,
  832. (mi->mpi.iChannels==2)?TRUE:FALSE, 1.0);
  833. }
  834. else 
  835. { // Scale, Truncate, and Clip
  836. float f;
  837. while (iNum--)
  838. { f=*pfBuf++*fScaleBy;
  839. if (f>=(float)(-32767.0))
  840. { if (f<=(float)32767.0)
  841. *piBuf++=(short)f;
  842. else
  843. *piBuf++=32767;
  844. }
  845. else
  846. *piBuf++=-32767;
  847. }
  848. }
  849. read/=2;
  850. }
  851. GlobalUnlock(hInput);
  852. }
  853. return read;
  854. }