My Pastes
Public Pastes
Layout Width
Share Pastebin
Guest
Public paste!

Woz

By: a guest | Aug 31st, 2010 | Syntax: None | Size: 6.59 KB | Hits: 27 | Expires: Never
Download | Raw | Embed | Report abuse
Copy text to clipboard
  1. #include "windows.h"
  2. #include "stdafx.h"
  3. #include "math.h"
  4.  
  5. DWORD dwCount;
  6. HANDLE fHnd;
  7. static HANDLE fHnd_Write;
  8. static HANDLE fHnd_Read;
  9.  
  10.  
  11.  
  12. typedef DWORD (CALLBACK* LPFNDLL_WAVInit) ( LPCTSTR pContext, LPCVOID lpvBusContext);
  13. typedef DWORD (CALLBACK* LPFNDLL_WAV_Init)(LPCTSTR pContext, LPCVOID lpvBusContext);
  14. typedef BOOL (CALLBACK* LPFNDLL_WAV_Deinit)( DWORD hDeviceContext );
  15. typedef DWORD (CALLBACK* LPFNDLL_WAV_Open)( DWORD hDeviceContext, DWORD AccessCode, DWORD ShareMode );
  16. typedef BOOL (CALLBACK* LPFNDLL_WAV_Close)( DWORD hOpenContext );
  17. typedef BOOL (CALLBACK* LPFNDLL_WAV_IOControl)( DWORD hOpenContext, DWORD dwCode, PBYTE pBufIn,
  18.                                                 DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut );
  19. typedef void (CALLBACK* LPFNDLL_WAV_PowerUp)( DWORD hDeviceContext );
  20. typedef void (CALLBACK* LPFNDLL_WAV_PowerDown)( DWORD hDeviceContext );
  21. typedef DWORD (CALLBACK* LPFNDLL_WAV_Read)( DWORD hOpenContext, LPVOID pBuffer, DWORD Count );
  22. typedef DWORD (CALLBACK* LPFNDLL_WAV_Write)( DWORD hOpenContext, LPCVOID pBuffer, DWORD Count );
  23. typedef DWORD (CALLBACK* LPFNDLL_WAV_Seek)( DWORD hOpenContext, long Amount, WORD Type );
  24.  
  25. HANDLE hActualDriver = NULL;
  26.  
  27. LPFNDLL_WAV_Init fptr_init;
  28. LPFNDLL_WAV_Deinit fptr_deinit;
  29. LPFNDLL_WAV_Open fptr_open;
  30. LPFNDLL_WAV_Close fptr_close;
  31. LPFNDLL_WAV_IOControl fptr_iocontrol;
  32.  
  33. FILE* f;
  34.  
  35. typedef struct {
  36.   unsigned int uDeviceId;
  37.   unsigned int uMsg;
  38.   unsigned int dwUser;
  39.   unsigned int dwParam1;
  40.   unsigned int dwParam2;
  41. } MMMDRV_MESSAGE_PARAMS;
  42.  
  43. typedef struct {
  44.   char* lpData;
  45.   unsigned int dwBufferLength;
  46.   unsigned int dwBytesRecorded;
  47.   unsigned int dwUser;
  48.   unsigned int dwFlags;
  49.   unsigned int dwLoops;
  50.   void* lpNext;
  51.   unsigned int reserved;
  52. } MWAVEHDR;
  53.  
  54. typedef struct {
  55.   unsigned int hWave;
  56.   void* lpFormat;
  57.   void* dwCallback;
  58.   unsigned int dwInstance;
  59.   unsigned int uMappedDeviceID;
  60. } MWAVEOPENDESC;
  61.  
  62. typedef struct {
  63.   unsigned short  wFormatTag;
  64.   unsigned short  nChannels;
  65.   unsigned int nSamplesPerSec;
  66.   unsigned int nAvgBytesPerSec;
  67.   unsigned short  nBlockAlign;
  68.   unsigned short  wBitsPerSample;
  69.   unsigned short  cbSize;
  70. }MWAVEFORMATEX;
  71.  
  72. void* WAV_Init(char* key, unsigned int otherthing)
  73. {
  74.         return (void*)fptr_init((LPCTSTR)key,(LPCVOID)otherthing);
  75. }
  76.  
  77. void* WAV_Open(void* handle, unsigned int access, unsigned int mode)
  78. {
  79.         return (void*)fptr_open((DWORD)handle,(DWORD)access,(DWORD)mode);
  80. }
  81.  
  82. void* WAV_IOControl(void* handle, unsigned int code, void *pdata, unsigned int datasize, void* pout, unsigned int outsz, unsigned int*poutsz)
  83. {
  84.         return (void*)fptr_iocontrol((DWORD)handle,(DWORD)code,(PBYTE)pdata,(DWORD)datasize,(PBYTE)pout,(DWORD)outsz,(PDWORD)poutsz);
  85. }
  86.  
  87. unsigned int WODM_Open(void* handle, unsigned int hWave, void *lpFormat,void*dwCallback,unsigned int dwInstance, unsigned int uMappedDeviceID)
  88. {
  89.         unsigned int deviceinstance=0;
  90.  
  91.         MWAVEOPENDESC open;
  92.         open.hWave=hWave;
  93.         open.lpFormat=lpFormat;
  94.         open.dwCallback=dwCallback;
  95.         open.dwInstance=dwInstance;
  96.         open.uMappedDeviceID=uMappedDeviceID;
  97.  
  98.         MMMDRV_MESSAGE_PARAMS parms;
  99.         parms.dwUser = (unsigned int)&deviceinstance;
  100.         parms.uMsg = 0x5;
  101.         parms.dwParam1 = (unsigned int)&open;
  102.         parms.dwParam2 = 0x00030000;
  103.  
  104.         unsigned int bytes;
  105.         unsigned int result;
  106.         WAV_IOControl(handle,0x001d000c,&parms,sizeof(MMMDRV_MESSAGE_PARAMS),&bytes,0x04,&result);
  107.  
  108.         return deviceinstance;
  109. }
  110.  
  111. void opencallback()
  112. {
  113.         fprintf(f,"WODM_OPEN: Callback\n");
  114. }
  115.  
  116.  
  117.  
  118. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nShowCmd )
  119. {
  120.     HINSTANCE jh = NULL;
  121.  
  122.     f = fopen("wav.log","w+");
  123.     fprintf(f,"Init: \n");
  124.  
  125.  
  126.     hActualDriver = LoadLibrary(_T("wavedev.dlo"));//(HANDLE)
  127.     GetModuleHandle(_T("wavedev.dlo"));
  128.  
  129.     fptr_init = (LPFNDLL_WAV_Init)GetProcAddress((HMODULE)hActualDriver, _T("WAV_Init"));
  130.     fptr_deinit = (LPFNDLL_WAV_Deinit)GetProcAddress((HMODULE)hActualDriver, _T("WAV_DeInit"));
  131.     fptr_open = (LPFNDLL_WAV_Open)GetProcAddress((HMODULE)hActualDriver, _T("WAV_Open"));
  132.     fptr_close = (LPFNDLL_WAV_Close)GetProcAddress((HMODULE)hActualDriver, _T("WAV_Close"));
  133.     fptr_iocontrol = (LPFNDLL_WAV_IOControl)GetProcAddress((HMODULE)hActualDriver, _T("WAV_IOControl"));
  134.  
  135.  
  136.     void* whandle = WAV_Init("someregistrykey",0);
  137.  
  138.     fprintf(f,"WAV handle: %x\n", whandle);
  139.  
  140.     void* dhandle = WAV_Open(whandle,0,3);
  141.  
  142.     fprintf(f,"Device handle: %x\n", dhandle);
  143.  
  144.     MWAVEHDR wavehdr;
  145.     wavehdr.lpData = (char*)malloc(6138*64);
  146.     wavehdr.dwBufferLength = 6138*64;
  147.     wavehdr.dwBytesRecorded = 0;
  148.     wavehdr.dwLoops = 0;
  149.     wavehdr.dwFlags = 0;
  150.     wavehdr.lpNext = 0;
  151.     wavehdr.reserved = 0;
  152.  
  153.        
  154.  
  155.     MMMDRV_MESSAGE_PARAMS parms;
  156.  
  157.     unsigned int result;
  158.     unsigned int bytes[0x30];
  159.  
  160.     WAV_IOControl(dhandle,0x00321000,0,0,bytes,0x30,&result); //??
  161.        
  162.     //Open
  163.     //Close
  164.     parms.dwUser = 0;
  165.     parms.uMsg = 0x32;
  166.     parms.dwParam2 = 0;
  167.     parms.dwParam1 = 0;
  168.  
  169.     WAV_IOControl(dhandle,0x001d000c,&parms,sizeof(MMMDRV_MESSAGE_PARAMS),bytes,0x04,&result); //??
  170.        
  171.     parms.dwUser = 0;
  172.     parms.uMsg = 0x3;
  173.     parms.dwParam2 = 0;
  174.     parms.dwParam1 = 0;
  175.  
  176.     WAV_IOControl(dhandle,0x001d000c,&parms,sizeof(MMMDRV_MESSAGE_PARAMS),bytes,0x04,&result); //??
  177.  
  178.     //0x16
  179.     //0x16
  180.        
  181.     fptr_close((DWORD)dhandle);
  182.  
  183.     dhandle = WAV_Open(whandle,0xc0000000,3);
  184.     fptr_close((DWORD)dhandle);
  185.  
  186.     dhandle = WAV_Open(whandle,0,3);
  187.  
  188.     MWAVEFORMATEX format;
  189.     format.wFormatTag=1;
  190.     format.nChannels=1;
  191.     format.nSamplesPerSec=0x2B11;
  192.     format.nAvgBytesPerSec=0x5622;
  193.     format.nBlockAlign=2;
  194.     format.wBitsPerSample=0x10;
  195.     format.cbSize=0;
  196.  
  197.  
  198.     result = 0x50;
  199.     unsigned int dinstance = WODM_Open(dhandle,(unsigned int)&result,&format, (void*)opencallback, 0x00000000, 0x00000000);
  200.  
  201.  
  202.     parms.dwUser = dinstance;
  203.     parms.uDeviceId = 0; //1?
  204.     parms.uMsg = 17;//set volume
  205.     parms.dwParam2 = 0;
  206.     parms.dwParam1 = 5;
  207.     WAV_IOControl(dhandle,0x001d000c,&parms,sizeof(MMMDRV_MESSAGE_PARAMS),&result,4,0);
  208.  
  209.  
  210.     short* sound = (short*)wavehdr.lpData;
  211.         unsigned int sidx=0;
  212.         for(sidx=0; sidx<6138*64/2; sidx++)
  213.         {
  214.                 //sound[sidx] = (short)((sidx%12>6)?4000:-4000);
  215.         }
  216.  
  217.     parms.uMsg = 7; //WODM_PREPARE
  218.     parms.dwParam2 = sizeof(WAVEHDR);
  219.     parms.dwParam1 = (unsigned int)&wavehdr;
  220.     WAV_IOControl(dhandle,0x001d000c,&parms,sizeof(MMMDRV_MESSAGE_PARAMS),&result,4,0);
  221.  
  222.  
  223.     parms.uMsg = 9; //WODM_WRITE
  224.     wavehdr.dwFlags = 2;
  225.     WAV_IOControl(dhandle,0x001d000c,&parms,sizeof(MMMDRV_MESSAGE_PARAMS),&result,4,0);
  226.  
  227.     fprintf(f,"Done: \n");
  228.     fclose(f);
  229.     return 0;
  230. }
create new paste | create new version of this paste RAW Paste Data