飘云阁

 找回密码
 加入我们

QQ登录

只需一步,快速开始

查看: 12948|回复: 24

[x64] X64_Winmm.dll源码

  [复制链接]
  • TA的每日心情
    慵懒
    2015-8-14 00:08
  • 签到天数: 25 天

    [LV.4]偶尔看看III

    发表于 2015-6-27 17:28:18 | 显示全部楼层 |阅读模式
    本帖最后由 crackvip 于 2015-6-28 00:13 编辑

    参考
    https://www.chinapyg.com/thread-74566-1-1.html

    写了一个winmm.dll的代码

    码上来,供大家测试

    1. // 头文件
    2. #include <windows.h>

    3. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    4. // 导出函数
    5. #pragma comment(linker, "/EXPORT:CloseDriver=ChinaPYG_CloseDriver")
    6. #pragma comment(linker, "/EXPORT:DefDriverProc=ChinaPYG_DefDriverProc")
    7. #pragma comment(linker, "/EXPORT:DriverCallback=ChinaPYG_DriverCallback")
    8. #pragma comment(linker, "/EXPORT:DrvGetModuleHandle=ChinaPYG_DrvGetModuleHandle")
    9. #pragma comment(linker, "/EXPORT:GetDriverModuleHandle=ChinaPYG_GetDriverModuleHandle")
    10. #pragma comment(linker, "/EXPORT:NotifyCallbackData=ChinaPYG_NotifyCallbackData")
    11. #pragma comment(linker, "/EXPORT:OpenDriver=ChinaPYG_OpenDriver")
    12. #pragma comment(linker, "/EXPORT:PlaySound=ChinaPYG_PlaySound")
    13. #pragma comment(linker, "/EXPORT:PlaySoundA=ChinaPYG_PlaySoundA")
    14. #pragma comment(linker, "/EXPORT:PlaySoundW=ChinaPYG_PlaySoundW")
    15. #pragma comment(linker, "/EXPORT:SendDriverMessage=ChinaPYG_SendDriverMessage")
    16. #pragma comment(linker, "/EXPORT:WOW32DriverCallback=ChinaPYG_WOW32DriverCallback")
    17. #pragma comment(linker, "/EXPORT:WOW32ResolveMultiMediaHandle=ChinaPYG_WOW32ResolveMultiMediaHandle")
    18. #pragma comment(linker, "/EXPORT:WOWAppExit=ChinaPYG_WOWAppExit")
    19. #pragma comment(linker, "/EXPORT:aux32Message=ChinaPYG_aux32Message")
    20. #pragma comment(linker, "/EXPORT:auxGetDevCapsA=ChinaPYG_auxGetDevCapsA")
    21. #pragma comment(linker, "/EXPORT:auxGetDevCapsW=ChinaPYG_auxGetDevCapsW")
    22. #pragma comment(linker, "/EXPORT:auxGetNumDevs=ChinaPYG_auxGetNumDevs")
    23. #pragma comment(linker, "/EXPORT:auxGetVolume=ChinaPYG_auxGetVolume")
    24. #pragma comment(linker, "/EXPORT:auxOutMessage=ChinaPYG_auxOutMessage")
    25. #pragma comment(linker, "/EXPORT:auxSetVolume=ChinaPYG_auxSetVolume")
    26. #pragma comment(linker, "/EXPORT:joy32Message=ChinaPYG_joy32Message")
    27. #pragma comment(linker, "/EXPORT:joyConfigChanged=ChinaPYG_joyConfigChanged")
    28. #pragma comment(linker, "/EXPORT:joyGetDevCapsA=ChinaPYG_joyGetDevCapsA")
    29. #pragma comment(linker, "/EXPORT:joyGetDevCapsW=ChinaPYG_joyGetDevCapsW")
    30. #pragma comment(linker, "/EXPORT:joyGetNumDevs=ChinaPYG_joyGetNumDevs")
    31. #pragma comment(linker, "/EXPORT:joyGetPos=ChinaPYG_joyGetPos")
    32. #pragma comment(linker, "/EXPORT:joyGetPosEx=ChinaPYG_joyGetPosEx")
    33. #pragma comment(linker, "/EXPORT:joyGetThreshold=ChinaPYG_joyGetThreshold")
    34. #pragma comment(linker, "/EXPORT:joyReleaseCapture=ChinaPYG_joyReleaseCapture")
    35. #pragma comment(linker, "/EXPORT:joySetCapture=ChinaPYG_joySetCapture")
    36. #pragma comment(linker, "/EXPORT:joySetThreshold=ChinaPYG_joySetThreshold")
    37. #pragma comment(linker, "/EXPORT:mci32Message=ChinaPYG_mci32Message")
    38. #pragma comment(linker, "/EXPORT:mciDriverNotify=ChinaPYG_mciDriverNotify")
    39. #pragma comment(linker, "/EXPORT:mciDriverYield=ChinaPYG_mciDriverYield")
    40. #pragma comment(linker, "/EXPORT:mciExecute=ChinaPYG_mciExecute")
    41. #pragma comment(linker, "/EXPORT:mciFreeCommandResource=ChinaPYG_mciFreeCommandResource")
    42. #pragma comment(linker, "/EXPORT:mciGetCreatorTask=ChinaPYG_mciGetCreatorTask")
    43. #pragma comment(linker, "/EXPORT:mciGetDeviceIDA=ChinaPYG_mciGetDeviceIDA")
    44. #pragma comment(linker, "/EXPORT:mciGetDeviceIDFromElementIDA=ChinaPYG_mciGetDeviceIDFromElementIDA")
    45. #pragma comment(linker, "/EXPORT:mciGetDeviceIDFromElementIDW=ChinaPYG_mciGetDeviceIDFromElementIDW")
    46. #pragma comment(linker, "/EXPORT:mciGetDeviceIDW=ChinaPYG_mciGetDeviceIDW")
    47. #pragma comment(linker, "/EXPORT:mciGetDriverData=ChinaPYG_mciGetDriverData")
    48. #pragma comment(linker, "/EXPORT:mciGetErrorStringA=ChinaPYG_mciGetErrorStringA")
    49. #pragma comment(linker, "/EXPORT:mciGetErrorStringW=ChinaPYG_mciGetErrorStringW")
    50. #pragma comment(linker, "/EXPORT:mciGetYieldProc=ChinaPYG_mciGetYieldProc")
    51. #pragma comment(linker, "/EXPORT:mciLoadCommandResource=ChinaPYG_mciLoadCommandResource")
    52. #pragma comment(linker, "/EXPORT:mciSendCommandA=ChinaPYG_mciSendCommandA")
    53. #pragma comment(linker, "/EXPORT:mciSendCommandW=ChinaPYG_mciSendCommandW")
    54. #pragma comment(linker, "/EXPORT:mciSendStringA=ChinaPYG_mciSendStringA")
    55. #pragma comment(linker, "/EXPORT:mciSendStringW=ChinaPYG_mciSendStringW")
    56. #pragma comment(linker, "/EXPORT:mciSetDriverData=ChinaPYG_mciSetDriverData")
    57. #pragma comment(linker, "/EXPORT:mciSetYieldProc=ChinaPYG_mciSetYieldProc")
    58. #pragma comment(linker, "/EXPORT:mid32Message=ChinaPYG_mid32Message")
    59. #pragma comment(linker, "/EXPORT:midiConnect=ChinaPYG_midiConnect")
    60. #pragma comment(linker, "/EXPORT:midiDisconnect=ChinaPYG_midiDisconnect")
    61. #pragma comment(linker, "/EXPORT:midiInAddBuffer=ChinaPYG_midiInAddBuffer")
    62. #pragma comment(linker, "/EXPORT:midiInClose=ChinaPYG_midiInClose")
    63. #pragma comment(linker, "/EXPORT:midiInGetDevCapsA=ChinaPYG_midiInGetDevCapsA")
    64. #pragma comment(linker, "/EXPORT:midiInGetDevCapsW=ChinaPYG_midiInGetDevCapsW")
    65. #pragma comment(linker, "/EXPORT:midiInGetErrorTextA=ChinaPYG_midiInGetErrorTextA")
    66. #pragma comment(linker, "/EXPORT:midiInGetErrorTextW=ChinaPYG_midiInGetErrorTextW")
    67. #pragma comment(linker, "/EXPORT:midiInGetID=ChinaPYG_midiInGetID")
    68. #pragma comment(linker, "/EXPORT:midiInGetNumDevs=ChinaPYG_midiInGetNumDevs")
    69. #pragma comment(linker, "/EXPORT:midiInMessage=ChinaPYG_midiInMessage")
    70. #pragma comment(linker, "/EXPORT:midiInOpen=ChinaPYG_midiInOpen")
    71. #pragma comment(linker, "/EXPORT:midiInPrepareHeader=ChinaPYG_midiInPrepareHeader")
    72. #pragma comment(linker, "/EXPORT:midiInReset=ChinaPYG_midiInReset")
    73. #pragma comment(linker, "/EXPORT:midiInStart=ChinaPYG_midiInStart")
    74. #pragma comment(linker, "/EXPORT:midiInStop=ChinaPYG_midiInStop")
    75. #pragma comment(linker, "/EXPORT:midiInUnprepareHeader=ChinaPYG_midiInUnprepareHeader")
    76. #pragma comment(linker, "/EXPORT:midiOutCacheDrumPatches=ChinaPYG_midiOutCacheDrumPatches")
    77. #pragma comment(linker, "/EXPORT:midiOutCachePatches=ChinaPYG_midiOutCachePatches")
    78. #pragma comment(linker, "/EXPORT:midiOutClose=ChinaPYG_midiOutClose")
    79. #pragma comment(linker, "/EXPORT:midiOutGetDevCapsA=ChinaPYG_midiOutGetDevCapsA")
    80. #pragma comment(linker, "/EXPORT:midiOutGetDevCapsW=ChinaPYG_midiOutGetDevCapsW")
    81. #pragma comment(linker, "/EXPORT:midiOutGetErrorTextA=ChinaPYG_midiOutGetErrorTextA")
    82. #pragma comment(linker, "/EXPORT:midiOutGetErrorTextW=ChinaPYG_midiOutGetErrorTextW")
    83. #pragma comment(linker, "/EXPORT:midiOutGetID=ChinaPYG_midiOutGetID")
    84. #pragma comment(linker, "/EXPORT:midiOutGetNumDevs=ChinaPYG_midiOutGetNumDevs")
    85. #pragma comment(linker, "/EXPORT:midiOutGetVolume=ChinaPYG_midiOutGetVolume")
    86. #pragma comment(linker, "/EXPORT:midiOutLongMsg=ChinaPYG_midiOutLongMsg")
    87. #pragma comment(linker, "/EXPORT:midiOutMessage=ChinaPYG_midiOutMessage")
    88. #pragma comment(linker, "/EXPORT:midiOutOpen=ChinaPYG_midiOutOpen")
    89. #pragma comment(linker, "/EXPORT:midiOutPrepareHeader=ChinaPYG_midiOutPrepareHeader")
    90. #pragma comment(linker, "/EXPORT:midiOutReset=ChinaPYG_midiOutReset")
    91. #pragma comment(linker, "/EXPORT:midiOutSetVolume=ChinaPYG_midiOutSetVolume")
    92. #pragma comment(linker, "/EXPORT:midiOutShortMsg=ChinaPYG_midiOutShortMsg")
    93. #pragma comment(linker, "/EXPORT:midiOutUnprepareHeader=ChinaPYG_midiOutUnprepareHeader")
    94. #pragma comment(linker, "/EXPORT:midiStreamClose=ChinaPYG_midiStreamClose")
    95. #pragma comment(linker, "/EXPORT:midiStreamOpen=ChinaPYG_midiStreamOpen")
    96. #pragma comment(linker, "/EXPORT:midiStreamOut=ChinaPYG_midiStreamOut")
    97. #pragma comment(linker, "/EXPORT:midiStreamPause=ChinaPYG_midiStreamPause")
    98. #pragma comment(linker, "/EXPORT:midiStreamPosition=ChinaPYG_midiStreamPosition")
    99. #pragma comment(linker, "/EXPORT:midiStreamProperty=ChinaPYG_midiStreamProperty")
    100. #pragma comment(linker, "/EXPORT:midiStreamRestart=ChinaPYG_midiStreamRestart")
    101. #pragma comment(linker, "/EXPORT:midiStreamStop=ChinaPYG_midiStreamStop")
    102. #pragma comment(linker, "/EXPORT:mixerClose=ChinaPYG_mixerClose")
    103. #pragma comment(linker, "/EXPORT:mixerGetControlDetailsA=ChinaPYG_mixerGetControlDetailsA")
    104. #pragma comment(linker, "/EXPORT:mixerGetControlDetailsW=ChinaPYG_mixerGetControlDetailsW")
    105. #pragma comment(linker, "/EXPORT:mixerGetDevCapsA=ChinaPYG_mixerGetDevCapsA")
    106. #pragma comment(linker, "/EXPORT:mixerGetDevCapsW=ChinaPYG_mixerGetDevCapsW")
    107. #pragma comment(linker, "/EXPORT:mixerGetID=ChinaPYG_mixerGetID")
    108. #pragma comment(linker, "/EXPORT:mixerGetLineControlsA=ChinaPYG_mixerGetLineControlsA")
    109. #pragma comment(linker, "/EXPORT:mixerGetLineControlsW=ChinaPYG_mixerGetLineControlsW")
    110. #pragma comment(linker, "/EXPORT:mixerGetLineInfoA=ChinaPYG_mixerGetLineInfoA")
    111. #pragma comment(linker, "/EXPORT:mixerGetLineInfoW=ChinaPYG_mixerGetLineInfoW")
    112. #pragma comment(linker, "/EXPORT:mixerGetNumDevs=ChinaPYG_mixerGetNumDevs")
    113. #pragma comment(linker, "/EXPORT:mixerMessage=ChinaPYG_mixerMessage")
    114. #pragma comment(linker, "/EXPORT:mixerOpen=ChinaPYG_mixerOpen")
    115. #pragma comment(linker, "/EXPORT:mixerSetControlDetails=ChinaPYG_mixerSetControlDetails")
    116. #pragma comment(linker, "/EXPORT:mmDrvInstall=ChinaPYG_mmDrvInstall")
    117. #pragma comment(linker, "/EXPORT:mmGetCurrentTask=ChinaPYG_mmGetCurrentTask")
    118. #pragma comment(linker, "/EXPORT:mmTaskBlock=ChinaPYG_mmTaskBlock")
    119. #pragma comment(linker, "/EXPORT:mmTaskCreate=ChinaPYG_mmTaskCreate")
    120. #pragma comment(linker, "/EXPORT:mmTaskSignal=ChinaPYG_mmTaskSignal")
    121. #pragma comment(linker, "/EXPORT:mmTaskYield=ChinaPYG_mmTaskYield")
    122. #pragma comment(linker, "/EXPORT:mmioAdvance=ChinaPYG_mmioAdvance")
    123. #pragma comment(linker, "/EXPORT:mmioAscend=ChinaPYG_mmioAscend")
    124. #pragma comment(linker, "/EXPORT:mmioClose=ChinaPYG_mmioClose")
    125. #pragma comment(linker, "/EXPORT:mmioCreateChunk=ChinaPYG_mmioCreateChunk")
    126. #pragma comment(linker, "/EXPORT:mmioDescend=ChinaPYG_mmioDescend")
    127. #pragma comment(linker, "/EXPORT:mmioFlush=ChinaPYG_mmioFlush")
    128. #pragma comment(linker, "/EXPORT:mmioGetInfo=ChinaPYG_mmioGetInfo")
    129. #pragma comment(linker, "/EXPORT:mmioInstallIOProcA=ChinaPYG_mmioInstallIOProcA")
    130. #pragma comment(linker, "/EXPORT:mmioInstallIOProcW=ChinaPYG_mmioInstallIOProcW")
    131. #pragma comment(linker, "/EXPORT:mmioOpenA=ChinaPYG_mmioOpenA")
    132. #pragma comment(linker, "/EXPORT:mmioOpenW=ChinaPYG_mmioOpenW")
    133. #pragma comment(linker, "/EXPORT:mmioRead=ChinaPYG_mmioRead")
    134. #pragma comment(linker, "/EXPORT:mmioRenameA=ChinaPYG_mmioRenameA")
    135. #pragma comment(linker, "/EXPORT:mmioRenameW=ChinaPYG_mmioRenameW")
    136. #pragma comment(linker, "/EXPORT:mmiOSeek=ChinaPYG_mmioSeek")
    137. #pragma comment(linker, "/EXPORT:mmioSendMessage=ChinaPYG_mmioSendMessage")
    138. #pragma comment(linker, "/EXPORT:mmioSetBuffer=ChinaPYG_mmioSetBuffer")
    139. #pragma comment(linker, "/EXPORT:mmioSetInfo=ChinaPYG_mmioSetInfo")
    140. #pragma comment(linker, "/EXPORT:mmioStringToFOURCCA=ChinaPYG_mmioStringToFOURCCA")
    141. #pragma comment(linker, "/EXPORT:mmioStringToFOURCCW=ChinaPYG_mmioStringToFOURCCW")
    142. #pragma comment(linker, "/EXPORT:mmioWrite=ChinaPYG_mmioWrite")
    143. #pragma comment(linker, "/EXPORT:mmsystemGetVersion=ChinaPYG_mmsystemGetVersion")
    144. #pragma comment(linker, "/EXPORT:mod32Message=ChinaPYG_mod32Message")
    145. #pragma comment(linker, "/EXPORT:mxd32Message=ChinaPYG_mxd32Message")
    146. #pragma comment(linker, "/EXPORT:sndPlaySoundA=ChinaPYG_sndPlaySoundA")
    147. #pragma comment(linker, "/EXPORT:sndPlaySoundW=ChinaPYG_sndPlaySoundW")
    148. #pragma comment(linker, "/EXPORT:tid32Message=ChinaPYG_tid32Message")
    149. #pragma comment(linker, "/EXPORT:timeBeginPeriod=ChinaPYG_timeBeginPeriod")
    150. #pragma comment(linker, "/EXPORT:timeEndPeriod=ChinaPYG_timeEndPeriod")
    151. #pragma comment(linker, "/EXPORT:timeGetDevCaps=ChinaPYG_timeGetDevCaps")
    152. #pragma comment(linker, "/EXPORT:timeGetSystemTime=ChinaPYG_timeGetSystemTime")
    153. #pragma comment(linker, "/EXPORT:timeGetTime=ChinaPYG_timeGetTime")
    154. #pragma comment(linker, "/EXPORT:timeKillEvent=ChinaPYG_timeKillEvent")
    155. #pragma comment(linker, "/EXPORT:timeSetEvent=ChinaPYG_timeSetEvent")
    156. #pragma comment(linker, "/EXPORT:waveInAddBuffer=ChinaPYG_waveInAddBuffer")
    157. #pragma comment(linker, "/EXPORT:waveInClose=ChinaPYG_waveInClose")
    158. #pragma comment(linker, "/EXPORT:waveInGetDevCapsA=ChinaPYG_waveInGetDevCapsA")
    159. #pragma comment(linker, "/EXPORT:waveInGetDevCapsW=ChinaPYG_waveInGetDevCapsW")
    160. #pragma comment(linker, "/EXPORT:waveInGetErrorTextA=ChinaPYG_waveInGetErrorTextA")
    161. #pragma comment(linker, "/EXPORT:waveInGetErrorTextW=ChinaPYG_waveInGetErrorTextW")
    162. #pragma comment(linker, "/EXPORT:waveInGetID=ChinaPYG_waveInGetID")
    163. #pragma comment(linker, "/EXPORT:waveInGetNumDevs=ChinaPYG_waveInGetNumDevs")
    164. #pragma comment(linker, "/EXPORT:waveInGetPosition=ChinaPYG_waveInGetPosition")
    165. #pragma comment(linker, "/EXPORT:waveInMessage=ChinaPYG_waveInMessage")
    166. #pragma comment(linker, "/EXPORT:waveInOpen=ChinaPYG_waveInOpen")
    167. #pragma comment(linker, "/EXPORT:waveInPrepareHeader=ChinaPYG_waveInPrepareHeader")
    168. #pragma comment(linker, "/EXPORT:waveInReset=ChinaPYG_waveInReset")
    169. #pragma comment(linker, "/EXPORT:waveInStart=ChinaPYG_waveInStart")
    170. #pragma comment(linker, "/EXPORT:waveInStop=ChinaPYG_waveInStop")
    171. #pragma comment(linker, "/EXPORT:waveInUnprepareHeader=ChinaPYG_waveInUnprepareHeader")
    172. #pragma comment(linker, "/EXPORT:waveOutBreakLoop=ChinaPYG_waveOutBreakLoop")
    173. #pragma comment(linker, "/EXPORT:waveOutClose=ChinaPYG_waveOutClose")
    174. #pragma comment(linker, "/EXPORT:waveOutGetDevCapsA=ChinaPYG_waveOutGetDevCapsA")
    175. #pragma comment(linker, "/EXPORT:waveOutGetDevCapsW=ChinaPYG_waveOutGetDevCapsW")
    176. #pragma comment(linker, "/EXPORT:waveOutGetErrorTextA=ChinaPYG_waveOutGetErrorTextA")
    177. #pragma comment(linker, "/EXPORT:waveOutGetErrorTextW=ChinaPYG_waveOutGetErrorTextW")
    178. #pragma comment(linker, "/EXPORT:waveOutGetID=ChinaPYG_waveOutGetID")
    179. #pragma comment(linker, "/EXPORT:waveOutGetNumDevs=ChinaPYG_waveOutGetNumDevs")
    180. #pragma comment(linker, "/EXPORT:waveOutGetPitch=ChinaPYG_waveOutGetPitch")
    181. #pragma comment(linker, "/EXPORT:waveOutGetPlaybackRate=ChinaPYG_waveOutGetPlaybackRate")
    182. #pragma comment(linker, "/EXPORT:waveOutGetPosition=ChinaPYG_waveOutGetPosition")
    183. #pragma comment(linker, "/EXPORT:waveOutGetVolume=ChinaPYG_waveOutGetVolume")
    184. #pragma comment(linker, "/EXPORT:waveOutMessage=ChinaPYG_waveOutMessage")
    185. #pragma comment(linker, "/EXPORT:waveOutOpen=ChinaPYG_waveOutOpen")
    186. #pragma comment(linker, "/EXPORT:waveOutPause=ChinaPYG_waveOutPause")
    187. #pragma comment(linker, "/EXPORT:waveOutPrepareHeader=ChinaPYG_waveOutPrepareHeader")
    188. #pragma comment(linker, "/EXPORT:waveOutReset=ChinaPYG_waveOutReset")
    189. #pragma comment(linker, "/EXPORT:waveOutRestart=ChinaPYG_waveOutRestart")
    190. #pragma comment(linker, "/EXPORT:waveOutSetPitch=ChinaPYG_waveOutSetPitch")
    191. #pragma comment(linker, "/EXPORT:waveOutSetPlaybackRate=ChinaPYG_waveOutSetPlaybackRate")
    192. #pragma comment(linker, "/EXPORT:waveOutSetVolume=ChinaPYG_waveOutSetVolume")
    193. #pragma comment(linker, "/EXPORT:waveOutUnprepareHeader=ChinaPYG_waveOutUnprepareHeader")
    194. #pragma comment(linker, "/EXPORT:waveOutWrite=ChinaPYG_waveOutWrite")
    195. #pragma comment(linker, "/EXPORT:wid32Message=ChinaPYG_wid32Message")
    196. #pragma comment(linker, "/EXPORT:wod32Message=ChinaPYG_wod32Message")

    197. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    198. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    199. // 宏定义
    200. #define EXTERNC extern "C"
    201. #define ALSTD EXTERNC void __stdcall
    202. #define ALCDECL EXTERNC void __cdecl
    203. #define LOAD_ERROR TEXT("无法加载 %s,程序无法正常运行。")
    204. #define FUN_ERROR TEXT("无法找到函数 %hs,程序无法正常运行。")
    205. #define APPNAME TEXT("\\falcwav_64.exe")
    206. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    207. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    208. // 汇编函数声明
    209. ALSTD JmpAddr(INT64 _addr);
    210. ALSTD PatchBYTE(INT64 addr, byte data);
    211. ALSTD PatchWORD(INT64 addr, WORD data);
    212. ALSTD PatchDWORD(INT64 addr, DWORD data);
    213. ALSTD PatchQWORD(INT64 addr, INT64 data);
    214. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


    215. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    216. // ChinaPYG 命名空间
    217. namespace ChinaPYG
    218. {
    219.         HMODULE m_hModule = NULL;        // 原始模块句柄
    220.         DWORD m_dwReturn[5] = {0};        // 原始函数返回地址

    221.         // 加载原始模块
    222.         inline BOOL WINAPI Load()
    223.         {
    224.                 TCHAR tzPath[MAX_PATH];
    225.                 TCHAR tzTemp[MAX_PATH * 2];

    226.                 GetSystemDirectory(tzPath, MAX_PATH);
    227.                 lstrcat(tzPath, TEXT("\\winmm.dll"));
    228.                 m_hModule = LoadLibrary(tzPath);
    229.                 if (m_hModule == NULL)
    230.                 {
    231.                         wsprintf(tzTemp, LOAD_ERROR, tzPath);
    232.                         MessageBox(NULL, tzTemp, TEXT("提示"), MB_ICONSTOP);
    233.                 }
    234.                 return (m_hModule != NULL);
    235.         }

    236.         // 释放原始模块
    237.         inline VOID WINAPI Free()
    238.         {
    239.                 if (m_hModule)
    240.                 {
    241.                         FreeLibrary(m_hModule);
    242.                 }
    243.         }

    244.         // 获取原始函数地址
    245.         FARPROC WINAPI GetAddress(PCSTR pszProcName)
    246.         {
    247.                 FARPROC fpAddress;
    248.                 CHAR szProcName[16];
    249.                 TCHAR tzTemp[MAX_PATH];

    250.                 if (m_hModule == NULL)
    251.                 {
    252.                         if (Load() == FALSE)
    253.                         {
    254.                                 ExitProcess(-1);
    255.                         }
    256.                 }

    257.                 fpAddress = GetProcAddress(m_hModule, pszProcName);
    258.                 if (fpAddress == NULL)
    259.                 {
    260.                         if (HIWORD(pszProcName) == 0)
    261.                         {
    262.                                 wsprintf(szProcName, "%d", pszProcName);
    263.                                 pszProcName = szProcName;
    264.                         }
    265.                         wsprintf(tzTemp, FUN_ERROR, pszProcName);
    266.                         MessageBox(NULL, tzTemp,TEXT("错误"), MB_ICONSTOP);
    267.                         ExitProcess(-2);
    268.                 }

    269.                 return fpAddress;
    270.         }
    271. }
    272. using namespace ChinaPYG;
    273. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    274. void PatchIt()
    275. {
    276.         // 写自己的Patch代码

    277.         DWORD dwOldProtect;
    278.         HMODULE BaseAddr;
    279.         PVOID pAddr = NULL;
    280.         INT64 PatchAddr;
    281.          TCHAR szFileName[MAX_PATH] = { 0 };
    282.         TCHAR szCrackVip[MAX_PATH] = { 0 };

    283.          INT64 hLibrary = 0;
    284.          hLibrary = ::GetModuleFileName(NULL, szFileName, MAX_PATH);
    285.         if (hLibrary != NULL)
    286.         {
    287.                 ::OutputDebugString(TEXT("GetModuleFileName 成功"));
    288.                 wsprintf(szCrackVip,TEXT("程序地址:%s"),szFileName);

    289.                 ::OutputDebugString(szCrackVip);

    290. #ifdef _UNICODE
    291.                 pAddr = wcsstr(szFileName, APPNAME);
    292. #else
    293.                 pAddr = strstr(szFileName, APPNAME);
    294. #endif //_UNICODE
    295.                 if (pAddr!= NULL)
    296.                 {
    297.                 ::OutputDebugString(TEXT("程序匹配成功!"));
    298.                 BaseAddr = GetModuleHandle(NULL);

    299.                 wsprintf(szCrackVip, TEXT("程序基址:%.16X"), (INT64)BaseAddr);
    300.                 ::OutputDebugString(szCrackVip);

    301.                
    302.                 PatchAddr = (INT64)BaseAddr + 0x63C9;//patch地址

    303.                 wsprintf(szCrackVip, TEXT("补丁地址:%.16X"), (INT64)PatchAddr);
    304.                 ::OutputDebugString(szCrackVip);

    305.                 VirtualProtect((LPVOID)PatchAddr, 0x1000, PAGE_EXECUTE_READWRITE, &dwOldProtect);

    306.                 PatchBYTE(PatchAddr, 0x00);

    307.                 //PatchBYTE(IPatchAddr, 0x90);
    308.                 //PatchWORD(PatchAddr, 0x9090);
    309.                 //PatchDWORD(PatchAddr, 0x90909090);
    310.                 //PatchQWORD(PatchAddr, 0x9090909090909090);

    311.                 }

    312.                

    313.                 //VirtualProtect((LPVOID)PatchAddr, 4, PAGE_EXECUTE_READWRITE, &dwOldProtect);
    314.                 //*(PWORD)PatchAddr = 0x9090;
    315.                 //PatchWORD(PatchAddr, 0x9090);
    316.         }

    317. }

    318. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    319. // 入口函数
    320. BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
    321. {
    322.         switch (dwReason)
    323.         {
    324.                 case  DLL_PROCESS_ATTACH:
    325.                 {
    326.                         DisableThreadLibraryCalls(hModule);
    327.                         if(Load())
    328.                         {
    329.                                 PatchIt();
    330.                         }
    331.                         else
    332.                                 return FALSE;

    333.                         break;
    334.                 }
    335.                 case DLL_PROCESS_DETACH:
    336.                 {
    337.                         Free();
    338.                         break;
    339.                 }
    340.         }

    341.         return TRUE;
    342. }
    343. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    344. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////





    345. ALCDECL ChinaPYG_CloseDriver(void)
    346. {
    347.         JmpAddr((INT64)GetAddress("CloseDriver"));
    348. }

    349. ALCDECL ChinaPYG_DefDriverProc(void)
    350. {
    351.         JmpAddr((INT64)GetAddress("DefDriverProc"));
    352. }

    353. ALCDECL ChinaPYG_DriverCallback(void)
    354. {
    355.         JmpAddr((INT64)GetAddress("DriverCallback"));
    356. }

    357. ALCDECL ChinaPYG_DrvGetModuleHandle(void)
    358. {
    359.         JmpAddr((INT64)GetAddress("DrvGetModuleHandle"));
    360. }

    361. ALCDECL ChinaPYG_GetDriverModuleHandle(void)
    362. {
    363.         JmpAddr((INT64)GetAddress("GetDriverModuleHandle"));
    364. }

    365. ALCDECL ChinaPYG_NotifyCallbackData(void)
    366. {
    367.         JmpAddr((INT64)GetAddress("NotifyCallbackData"));
    368. }

    369. ALCDECL ChinaPYG_OpenDriver(void)
    370. {
    371.         JmpAddr((INT64)GetAddress("OpenDriver"));
    372. }

    373. ALCDECL ChinaPYG_PlaySound(void)
    374. {
    375.         JmpAddr((INT64)GetAddress("PlaySound"));
    376. }

    377. ALCDECL ChinaPYG_PlaySoundA(void)
    378. {
    379.         JmpAddr((INT64)GetAddress("PlaySoundA"));
    380. }

    381. ALCDECL ChinaPYG_PlaySoundW(void)
    382. {
    383.         JmpAddr((INT64)GetAddress("PlaySoundW"));
    384. }

    385. ALCDECL ChinaPYG_SendDriverMessage(void)
    386. {
    387.         JmpAddr((INT64)GetAddress("SendDriverMessage"));
    388. }

    389. ALCDECL ChinaPYG_WOW32DriverCallback(void)
    390. {
    391.         JmpAddr((INT64)GetAddress("WOW32DriverCallback"));
    392. }

    393. ALCDECL ChinaPYG_WOW32ResolveMultiMediaHandle(void)
    394. {
    395.         JmpAddr((INT64)GetAddress("WOW32ResolveMultiMediaHandle"));
    396. }

    397. ALCDECL ChinaPYG_WOWAppExit(void)
    398. {
    399.         JmpAddr((INT64)GetAddress("WOWAppExit"));
    400. }

    401. ALCDECL ChinaPYG_aux32Message(void)
    402. {
    403.         JmpAddr((INT64)GetAddress("aux32Message"));
    404. }

    405. ALCDECL ChinaPYG_auxGetDevCapsA(void)
    406. {
    407.         JmpAddr((INT64)GetAddress("auxGetDevCapsA"));
    408. }

    409. ALCDECL ChinaPYG_auxGetDevCapsW(void)
    410. {
    411.         JmpAddr((INT64)GetAddress("auxGetDevCapsW"));
    412. }

    413. ALCDECL ChinaPYG_auxGetNumDevs(void)
    414. {
    415.         JmpAddr((INT64)GetAddress("auxGetNumDevs"));
    416. }

    417. ALCDECL ChinaPYG_auxGetVolume(void)
    418. {
    419.         JmpAddr((INT64)GetAddress("auxGetVolume"));
    420. }

    421. ALCDECL ChinaPYG_auxOutMessage(void)
    422. {
    423.         JmpAddr((INT64)GetAddress("auxOutMessage"));
    424. }

    425. ALCDECL ChinaPYG_auxSetVolume(void)
    426. {
    427.         JmpAddr((INT64)GetAddress("auxSetVolume"));
    428. }

    429. ALCDECL ChinaPYG_joy32Message(void)
    430. {
    431.         JmpAddr((INT64)GetAddress("joy32Message"));
    432. }

    433. ALCDECL ChinaPYG_joyConfigChanged(void)
    434. {
    435.         JmpAddr((INT64)GetAddress("joyConfigChanged"));
    436. }

    437. ALCDECL ChinaPYG_joyGetDevCapsA(void)
    438. {
    439.         JmpAddr((INT64)GetAddress("joyGetDevCapsA"));
    440. }

    441. ALCDECL ChinaPYG_joyGetDevCapsW(void)
    442. {
    443.         JmpAddr((INT64)GetAddress("joyGetDevCapsW"));
    444. }

    445. ALCDECL ChinaPYG_joyGetNumDevs(void)
    446. {
    447.         JmpAddr((INT64)GetAddress("joyGetNumDevs"));
    448. }

    449. ALCDECL ChinaPYG_joyGetPos(void)
    450. {
    451.         JmpAddr((INT64)GetAddress("joyGetPos"));
    452. }

    453. ALCDECL ChinaPYG_joyGetPosEx(void)
    454. {
    455.         JmpAddr((INT64)GetAddress("joyGetPosEx"));
    456. }

    457. ALCDECL ChinaPYG_joyGetThreshold(void)
    458. {
    459.         JmpAddr((INT64)GetAddress("joyGetThreshold"));
    460. }

    461. ALCDECL ChinaPYG_joyReleaseCapture(void)
    462. {
    463.         JmpAddr((INT64)GetAddress("joyReleaseCapture"));
    464. }

    465. ALCDECL ChinaPYG_joySetCapture(void)
    466. {
    467.         JmpAddr((INT64)GetAddress("joySetCapture"));
    468. }

    469. ALCDECL ChinaPYG_joySetThreshold(void)
    470. {
    471.         JmpAddr((INT64)GetAddress("joySetThreshold"));
    472. }

    473. ALCDECL ChinaPYG_mci32Message(void)
    474. {
    475.         JmpAddr((INT64)GetAddress("mci32Message"));
    476. }

    477. ALCDECL ChinaPYG_mciDriverNotify(void)
    478. {
    479.         JmpAddr((INT64)GetAddress("mciDriverNotify"));
    480. }

    481. ALCDECL ChinaPYG_mciDriverYield(void)
    482. {
    483.         JmpAddr((INT64)GetAddress("mciDriverYield"));
    484. }

    485. ALCDECL ChinaPYG_mciExecute(void)
    486. {
    487.         JmpAddr((INT64)GetAddress("mciExecute"));
    488. }

    489. ALCDECL ChinaPYG_mciFreeCommandResource(void)
    490. {
    491.         JmpAddr((INT64)GetAddress("mciFreeCommandResource"));
    492. }

    493. ALCDECL ChinaPYG_mciGetCreatorTask(void)
    494. {
    495.         JmpAddr((INT64)GetAddress("mciGetCreatorTask"));
    496. }

    497. ALCDECL ChinaPYG_mciGetDeviceIDA(void)
    498. {
    499.         JmpAddr((INT64)GetAddress("mciGetDeviceIDA"));
    500. }

    501. ALCDECL ChinaPYG_mciGetDeviceIDFromElementIDA(void)
    502. {
    503.         JmpAddr((INT64)GetAddress("mciGetDeviceIDFromElementIDA"));
    504. }

    505. ALCDECL ChinaPYG_mciGetDeviceIDFromElementIDW(void)
    506. {
    507.         JmpAddr((INT64)GetAddress("mciGetDeviceIDFromElementIDW"));
    508. }

    509. ALCDECL ChinaPYG_mciGetDeviceIDW(void)
    510. {
    511.         JmpAddr((INT64)GetAddress("mciGetDeviceIDW"));
    512. }

    513. ALCDECL ChinaPYG_mciGetDriverData(void)
    514. {
    515.         JmpAddr((INT64)GetAddress("mciGetDriverData"));
    516. }

    517. ALCDECL ChinaPYG_mciGetErrorStringA(void)
    518. {
    519.         JmpAddr((INT64)GetAddress("mciGetErrorStringA"));
    520. }

    521. ALCDECL ChinaPYG_mciGetErrorStringW(void)
    522. {
    523.         JmpAddr((INT64)GetAddress("mciGetErrorStringW"));
    524. }

    525. ALCDECL ChinaPYG_mciGetYieldProc(void)
    526. {
    527.         JmpAddr((INT64)GetAddress("mciGetYieldProc"));
    528. }

    529. ALCDECL ChinaPYG_mciLoadCommandResource(void)
    530. {
    531.         JmpAddr((INT64)GetAddress("mciLoadCommandResource"));
    532. }

    533. ALCDECL ChinaPYG_mciSendCommandA(void)
    534. {
    535.         JmpAddr((INT64)GetAddress("mciSendCommandA"));
    536. }

    537. ALCDECL ChinaPYG_mciSendCommandW(void)
    538. {
    539.         JmpAddr((INT64)GetAddress("mciSendCommandW"));
    540. }

    541. ALCDECL ChinaPYG_mciSendStringA(void)
    542. {
    543.         JmpAddr((INT64)GetAddress("mciSendStringA"));
    544. }

    545. ALCDECL ChinaPYG_mciSendStringW(void)
    546. {
    547.         JmpAddr((INT64)GetAddress("mciSendStringW"));
    548. }

    549. ALCDECL ChinaPYG_mciSetDriverData(void)
    550. {
    551.         JmpAddr((INT64)GetAddress("mciSetDriverData"));
    552. }

    553. ALCDECL ChinaPYG_mciSetYieldProc(void)
    554. {
    555.         JmpAddr((INT64)GetAddress("mciSetYieldProc"));
    556. }

    557. ALCDECL ChinaPYG_mid32Message(void)
    558. {
    559.         JmpAddr((INT64)GetAddress("mid32Message"));
    560. }

    561. ALCDECL ChinaPYG_midiConnect(void)
    562. {
    563.         JmpAddr((INT64)GetAddress("midiConnect"));
    564. }

    565. ALCDECL ChinaPYG_midiDisconnect(void)
    566. {
    567.         JmpAddr((INT64)GetAddress("midiDisconnect"));
    568. }

    569. ALCDECL ChinaPYG_midiInAddBuffer(void)
    570. {
    571.         JmpAddr((INT64)GetAddress("midiInAddBuffer"));
    572. }

    573. ALCDECL ChinaPYG_midiInClose(void)
    574. {
    575.         JmpAddr((INT64)GetAddress("midiInClose"));
    576. }

    577. ALCDECL ChinaPYG_midiInGetDevCapsA(void)
    578. {
    579.         JmpAddr((INT64)GetAddress("midiInGetDevCapsA"));
    580. }

    581. ALCDECL ChinaPYG_midiInGetDevCapsW(void)
    582. {
    583.         JmpAddr((INT64)GetAddress("midiInGetDevCapsW"));
    584. }

    585. ALCDECL ChinaPYG_midiInGetErrorTextA(void)
    586. {
    587.         JmpAddr((INT64)GetAddress("midiInGetErrorTextA"));
    588. }

    589. ALCDECL ChinaPYG_midiInGetErrorTextW(void)
    590. {
    591.         JmpAddr((INT64)GetAddress("midiInGetErrorTextW"));
    592. }

    593. ALCDECL ChinaPYG_midiInGetID(void)
    594. {
    595.         JmpAddr((INT64)GetAddress("midiInGetID"));
    596. }

    597. ALCDECL ChinaPYG_midiInGetNumDevs(void)
    598. {
    599.         JmpAddr((INT64)GetAddress("midiInGetNumDevs"));
    600. }

    601. ALCDECL ChinaPYG_midiInMessage(void)
    602. {
    603.         JmpAddr((INT64)GetAddress("midiInMessage"));
    604. }

    605. ALCDECL ChinaPYG_midiInOpen(void)
    606. {
    607.         JmpAddr((INT64)GetAddress("midiInOpen"));
    608. }

    609. ALCDECL ChinaPYG_midiInPrepareHeader(void)
    610. {
    611.         JmpAddr((INT64)GetAddress("midiInPrepareHeader"));
    612. }

    613. ALCDECL ChinaPYG_midiInReset(void)
    614. {
    615.         JmpAddr((INT64)GetAddress("midiInReset"));
    616. }

    617. ALCDECL ChinaPYG_midiInStart(void)
    618. {
    619.         JmpAddr((INT64)GetAddress("midiInStart"));
    620. }

    621. ALCDECL ChinaPYG_midiInStop(void)
    622. {
    623.         JmpAddr((INT64)GetAddress("midiInStop"));
    624. }

    625. ALCDECL ChinaPYG_midiInUnprepareHeader(void)
    626. {
    627.         JmpAddr((INT64)GetAddress("midiInUnprepareHeader"));
    628. }

    629. ALCDECL ChinaPYG_midiOutCacheDrumPatches(void)
    630. {
    631.         JmpAddr((INT64)GetAddress("midiOutCacheDrumPatches"));
    632. }

    633. ALCDECL ChinaPYG_midiOutCachePatches(void)
    634. {
    635.         JmpAddr((INT64)GetAddress("midiOutCachePatches"));
    636. }

    637. ALCDECL ChinaPYG_midiOutClose(void)
    638. {
    639.         JmpAddr((INT64)GetAddress("midiOutClose"));
    640. }

    641. ALCDECL ChinaPYG_midiOutGetDevCapsA(void)
    642. {
    643.         JmpAddr((INT64)GetAddress("midiOutGetDevCapsA"));
    644. }

    645. ALCDECL ChinaPYG_midiOutGetDevCapsW(void)
    646. {
    647.         JmpAddr((INT64)GetAddress("midiOutGetDevCapsW"));
    648. }

    649. ALCDECL ChinaPYG_midiOutGetErrorTextA(void)
    650. {
    651.         JmpAddr((INT64)GetAddress("midiOutGetErrorTextA"));
    652. }

    653. ALCDECL ChinaPYG_midiOutGetErrorTextW(void)
    654. {
    655.         JmpAddr((INT64)GetAddress("midiOutGetErrorTextW"));
    656. }

    657. ALCDECL ChinaPYG_midiOutGetID(void)
    658. {
    659.         JmpAddr((INT64)GetAddress("midiOutGetID"));
    660. }

    661. ALCDECL ChinaPYG_midiOutGetNumDevs(void)
    662. {
    663.         JmpAddr((INT64)GetAddress("midiOutGetNumDevs"));
    664. }

    665. ALCDECL ChinaPYG_midiOutGetVolume(void)
    666. {
    667.         JmpAddr((INT64)GetAddress("midiOutGetVolume"));
    668. }

    669. ALCDECL ChinaPYG_midiOutLongMsg(void)
    670. {
    671.         JmpAddr((INT64)GetAddress("midiOutLongMsg"));
    672. }

    673. ALCDECL ChinaPYG_midiOutMessage(void)
    674. {
    675.         JmpAddr((INT64)GetAddress("midiOutMessage"));
    676. }

    677. ALCDECL ChinaPYG_midiOutOpen(void)
    678. {
    679.         JmpAddr((INT64)GetAddress("midiOutOpen"));
    680. }

    681. ALCDECL ChinaPYG_midiOutPrepareHeader(void)
    682. {
    683.         JmpAddr((INT64)GetAddress("midiOutPrepareHeader"));
    684. }

    685. ALCDECL ChinaPYG_midiOutReset(void)
    686. {
    687.         JmpAddr((INT64)GetAddress("midiOutReset"));
    688. }

    689. ALCDECL ChinaPYG_midiOutSetVolume(void)
    690. {
    691.         JmpAddr((INT64)GetAddress("midiOutSetVolume"));
    692. }

    693. ALCDECL ChinaPYG_midiOutShortMsg(void)
    694. {
    695.         JmpAddr((INT64)GetAddress("midiOutShortMsg"));
    696. }

    697. ALCDECL ChinaPYG_midiOutUnprepareHeader(void)
    698. {
    699.         JmpAddr((INT64)GetAddress("midiOutUnprepareHeader"));
    700. }

    701. ALCDECL ChinaPYG_midiStreamClose(void)
    702. {
    703.         JmpAddr((INT64)GetAddress("midiStreamClose"));
    704. }

    705. ALCDECL ChinaPYG_midiStreamOpen(void)
    706. {
    707.         JmpAddr((INT64)GetAddress("midiStreamOpen"));
    708. }

    709. ALCDECL ChinaPYG_midiStreamOut(void)
    710. {
    711.         JmpAddr((INT64)GetAddress("midiStreamOut"));
    712. }

    713. ALCDECL ChinaPYG_midiStreamPause(void)
    714. {
    715.         JmpAddr((INT64)GetAddress("midiStreamPause"));
    716. }

    717. ALCDECL ChinaPYG_midiStreamPosition(void)
    718. {
    719.         JmpAddr((INT64)GetAddress("midiStreamPosition"));
    720. }

    721. ALCDECL ChinaPYG_midiStreamProperty(void)
    722. {
    723.         JmpAddr((INT64)GetAddress("midiStreamProperty"));
    724. }

    725. ALCDECL ChinaPYG_midiStreamRestart(void)
    726. {
    727.         JmpAddr((INT64)GetAddress("midiStreamRestart"));
    728. }

    729. ALCDECL ChinaPYG_midiStreamStop(void)
    730. {
    731.         JmpAddr((INT64)GetAddress("midiStreamStop"));
    732. }

    733. ALCDECL ChinaPYG_mixerClose(void)
    734. {
    735.         JmpAddr((INT64)GetAddress("mixerClose"));
    736. }

    737. ALCDECL ChinaPYG_mixerGetControlDetailsA(void)
    738. {
    739.         JmpAddr((INT64)GetAddress("mixerGetControlDetailsA"));
    740. }

    741. ALCDECL ChinaPYG_mixerGetControlDetailsW(void)
    742. {
    743.         JmpAddr((INT64)GetAddress("mixerGetControlDetailsW"));
    744. }

    745. ALCDECL ChinaPYG_mixerGetDevCapsA(void)
    746. {
    747.         JmpAddr((INT64)GetAddress("mixerGetDevCapsA"));
    748. }

    749. ALCDECL ChinaPYG_mixerGetDevCapsW(void)
    750. {
    751.         JmpAddr((INT64)GetAddress("mixerGetDevCapsW"));
    752. }

    753. ALCDECL ChinaPYG_mixerGetID(void)
    754. {
    755.         JmpAddr((INT64)GetAddress("mixerGetID"));
    756. }

    757. ALCDECL ChinaPYG_mixerGetLineControlsA(void)
    758. {
    759.         JmpAddr((INT64)GetAddress("mixerGetLineControlsA"));
    760. }

    761. ALCDECL ChinaPYG_mixerGetLineControlsW(void)
    762. {
    763.         JmpAddr((INT64)GetAddress("mixerGetLineControlsW"));
    764. }

    765. ALCDECL ChinaPYG_mixerGetLineInfoA(void)
    766. {
    767.         JmpAddr((INT64)GetAddress("mixerGetLineInfoA"));
    768. }

    769. ALCDECL ChinaPYG_mixerGetLineInfoW(void)
    770. {
    771.         JmpAddr((INT64)GetAddress("mixerGetLineInfoW"));
    772. }

    773. ALCDECL ChinaPYG_mixerGetNumDevs(void)
    774. {
    775.         JmpAddr((INT64)GetAddress("mixerGetNumDevs"));
    776. }

    777. ALCDECL ChinaPYG_mixerMessage(void)
    778. {
    779.         JmpAddr((INT64)GetAddress("mixerMessage"));
    780. }

    781. ALCDECL ChinaPYG_mixerOpen(void)
    782. {
    783.         JmpAddr((INT64)GetAddress("mixerOpen"));
    784. }

    785. ALCDECL ChinaPYG_mixerSetControlDetails(void)
    786. {
    787.         JmpAddr((INT64)GetAddress("mixerSetControlDetails"));
    788. }

    789. ALCDECL ChinaPYG_mmDrvInstall(void)
    790. {
    791.         JmpAddr((INT64)GetAddress("mmDrvInstall"));
    792. }

    793. ALCDECL ChinaPYG_mmGetCurrentTask(void)
    794. {
    795.         JmpAddr((INT64)GetAddress("mmGetCurrentTask"));
    796. }

    797. ALCDECL ChinaPYG_mmTaskBlock(void)
    798. {
    799.         JmpAddr((INT64)GetAddress("mmTaskBlock"));
    800. }

    801. ALCDECL ChinaPYG_mmTaskCreate(void)
    802. {
    803.         JmpAddr((INT64)GetAddress("mmTaskCreate"));
    804. }

    805. ALCDECL ChinaPYG_mmTaskSignal(void)
    806. {
    807.         JmpAddr((INT64)GetAddress("mmTaskSignal"));
    808. }

    809. ALCDECL ChinaPYG_mmTaskYield(void)
    810. {
    811.         JmpAddr((INT64)GetAddress("mmTaskYield"));
    812. }

    813. ALCDECL ChinaPYG_mmioAdvance(void)
    814. {
    815.         JmpAddr((INT64)GetAddress("mmioAdvance"));
    816. }

    817. ALCDECL ChinaPYG_mmioAscend(void)
    818. {
    819.         JmpAddr((INT64)GetAddress("mmioAscend"));
    820. }

    821. ALCDECL ChinaPYG_mmioClose(void)
    822. {
    823.         JmpAddr((INT64)GetAddress("mmioClose"));
    824. }

    825. ALCDECL ChinaPYG_mmioCreateChunk(void)
    826. {
    827.         JmpAddr((INT64)GetAddress("mmioCreateChunk"));
    828. }

    829. ALCDECL ChinaPYG_mmioDescend(void)
    830. {
    831.         JmpAddr((INT64)GetAddress("mmioDescend"));
    832. }

    833. ALCDECL ChinaPYG_mmioFlush(void)
    834. {
    835.         JmpAddr((INT64)GetAddress("mmioFlush"));
    836. }

    837. ALCDECL ChinaPYG_mmioGetInfo(void)
    838. {
    839.         JmpAddr((INT64)GetAddress("mmioGetInfo"));
    840. }

    841. ALCDECL ChinaPYG_mmioInstallIOProcA(void)
    842. {
    843.         JmpAddr((INT64)GetAddress("mmioInstallIOProcA"));
    844. }

    845. ALCDECL ChinaPYG_mmioInstallIOProcW(void)
    846. {
    847.         JmpAddr((INT64)GetAddress("mmioInstallIOProcW"));
    848. }

    849. ALCDECL ChinaPYG_mmioOpenA(void)
    850. {
    851.         JmpAddr((INT64)GetAddress("mmioOpenA"));
    852. }

    853. ALCDECL ChinaPYG_mmioOpenW(void)
    854. {
    855.         JmpAddr((INT64)GetAddress("mmioOpenW"));
    856. }

    857. ALCDECL ChinaPYG_mmioRead(void)
    858. {
    859.         JmpAddr((INT64)GetAddress("mmioRead"));
    860. }

    861. ALCDECL ChinaPYG_mmioRenameA(void)
    862. {
    863.         JmpAddr((INT64)GetAddress("mmioRenameA"));
    864. }

    865. ALCDECL ChinaPYG_mmioRenameW(void)
    866. {
    867.         JmpAddr((INT64)GetAddress("mmioRenameW"));
    868. }

    869. ALCDECL ChinaPYG_mmioSeek(void)
    870. {
    871.         JmpAddr((INT64)GetAddress("mmioSeek"));
    872. }

    873. ALCDECL ChinaPYG_mmioSendMessage(void)
    874. {
    875.         JmpAddr((INT64)GetAddress("mmioSendMessage"));
    876. }

    877. ALCDECL ChinaPYG_mmioSetBuffer(void)
    878. {
    879.         JmpAddr((INT64)GetAddress("mmioSetBuffer"));
    880. }

    881. ALCDECL ChinaPYG_mmioSetInfo(void)
    882. {
    883.         JmpAddr((INT64)GetAddress("mmioSetInfo"));
    884. }

    885. ALCDECL ChinaPYG_mmioStringToFOURCCA(void)
    886. {
    887.         JmpAddr((INT64)GetAddress("mmioStringToFOURCCA"));
    888. }

    889. ALCDECL ChinaPYG_mmioStringToFOURCCW(void)
    890. {
    891.         JmpAddr((INT64)GetAddress("mmioStringToFOURCCW"));
    892. }

    893. ALCDECL ChinaPYG_mmioWrite(void)
    894. {
    895.         JmpAddr((INT64)GetAddress("mmioWrite"));
    896. }

    897. ALCDECL ChinaPYG_mmsystemGetVersion(void)
    898. {
    899.         JmpAddr((INT64)GetAddress("mmsystemGetVersion"));
    900. }

    901. ALCDECL ChinaPYG_mod32Message(void)
    902. {
    903.         JmpAddr((INT64)GetAddress("mod32Message"));
    904. }

    905. ALCDECL ChinaPYG_mxd32Message(void)
    906. {
    907.         JmpAddr((INT64)GetAddress("mxd32Message"));
    908. }

    909. ALCDECL ChinaPYG_sndPlaySoundA(void)
    910. {
    911.         JmpAddr((INT64)GetAddress("sndPlaySoundA"));
    912. }

    913. ALCDECL ChinaPYG_sndPlaySoundW(void)
    914. {
    915.         JmpAddr((INT64)GetAddress("sndPlaySoundW"));
    916. }

    917. ALCDECL ChinaPYG_tid32Message(void)
    918. {
    919.         JmpAddr((INT64)GetAddress("tid32Message"));
    920. }

    921. ALCDECL ChinaPYG_timeBeginPeriod(void)
    922. {
    923.         JmpAddr((INT64)GetAddress("timeBeginPeriod"));
    924. }

    925. ALCDECL ChinaPYG_timeEndPeriod(void)
    926. {
    927.         JmpAddr((INT64)GetAddress("timeEndPeriod"));
    928. }

    929. ALCDECL ChinaPYG_timeGetDevCaps(void)
    930. {
    931.         JmpAddr((INT64)GetAddress("timeGetDevCaps"));
    932. }

    933. ALCDECL ChinaPYG_timeGetSystemTime(void)
    934. {
    935.         JmpAddr((INT64)GetAddress("timeGetSystemTime"));
    936. }

    937. ALCDECL ChinaPYG_timeGetTime(void)
    938. {
    939.         JmpAddr((INT64)GetAddress("timeGetTime"));
    940. }

    941. ALCDECL ChinaPYG_timeKillEvent(void)
    942. {
    943.         JmpAddr((INT64)GetAddress("timeKillEvent"));
    944. }

    945. ALCDECL ChinaPYG_timeSetEvent(void)
    946. {
    947.         JmpAddr((INT64)GetAddress("timeSetEvent"));
    948. }

    949. ALCDECL ChinaPYG_waveInAddBuffer(void)
    950. {
    951.         JmpAddr((INT64)GetAddress("waveInAddBuffer"));
    952. }

    953. ALCDECL ChinaPYG_waveInClose(void)
    954. {
    955.         JmpAddr((INT64)GetAddress("waveInClose"));
    956. }

    957. ALCDECL ChinaPYG_waveInGetDevCapsA(void)
    958. {
    959.         JmpAddr((INT64)GetAddress("waveInGetDevCapsA"));
    960. }

    961. ALCDECL ChinaPYG_waveInGetDevCapsW(void)
    962. {
    963.         JmpAddr((INT64)GetAddress("waveInGetDevCapsW"));
    964. }

    965. ALCDECL ChinaPYG_waveInGetErrorTextA(void)
    966. {
    967.         JmpAddr((INT64)GetAddress("waveInGetErrorTextA"));
    968. }

    969. ALCDECL ChinaPYG_waveInGetErrorTextW(void)
    970. {
    971.         JmpAddr((INT64)GetAddress("waveInGetErrorTextW"));
    972. }

    973. ALCDECL ChinaPYG_waveInGetID(void)
    974. {
    975.         JmpAddr((INT64)GetAddress("waveInGetID"));
    976. }

    977. ALCDECL ChinaPYG_waveInGetNumDevs(void)
    978. {
    979.         JmpAddr((INT64)GetAddress("waveInGetNumDevs"));
    980. }

    981. ALCDECL ChinaPYG_waveInGetPosition(void)
    982. {
    983.         JmpAddr((INT64)GetAddress("waveInGetPosition"));
    984. }

    985. ALCDECL ChinaPYG_waveInMessage(void)
    986. {
    987.         JmpAddr((INT64)GetAddress("waveInMessage"));
    988. }

    989. ALCDECL ChinaPYG_waveInOpen(void)
    990. {
    991.         JmpAddr((INT64)GetAddress("waveInOpen"));
    992. }

    993. ALCDECL ChinaPYG_waveInPrepareHeader(void)
    994. {
    995.         JmpAddr((INT64)GetAddress("waveInPrepareHeader"));
    996. }

    997. ALCDECL ChinaPYG_waveInReset(void)
    998. {
    999.         JmpAddr((INT64)GetAddress("waveInReset"));
    1000. }

    1001. ALCDECL ChinaPYG_waveInStart(void)
    1002. {
    1003.         JmpAddr((INT64)GetAddress("waveInStart"));
    1004. }

    1005. ALCDECL ChinaPYG_waveInStop(void)
    1006. {
    1007.         JmpAddr((INT64)GetAddress("waveInStop"));
    1008. }

    1009. ALCDECL ChinaPYG_waveInUnprepareHeader(void)
    1010. {
    1011.         JmpAddr((INT64)GetAddress("waveInUnprepareHeader"));
    1012. }

    1013. ALCDECL ChinaPYG_waveOutBreakLoop(void)
    1014. {
    1015.         JmpAddr((INT64)GetAddress("waveOutBreakLoop"));
    1016. }

    1017. ALCDECL ChinaPYG_waveOutClose(void)
    1018. {
    1019.         JmpAddr((INT64)GetAddress("waveOutClose"));
    1020. }

    1021. ALCDECL ChinaPYG_waveOutGetDevCapsA(void)
    1022. {
    1023.         JmpAddr((INT64)GetAddress("waveOutGetDevCapsA"));
    1024. }

    1025. ALCDECL ChinaPYG_waveOutGetDevCapsW(void)
    1026. {
    1027.         JmpAddr((INT64)GetAddress("waveOutGetDevCapsW"));
    1028. }

    1029. ALCDECL ChinaPYG_waveOutGetErrorTextA(void)
    1030. {
    1031.         JmpAddr((INT64)GetAddress("waveOutGetErrorTextA"));
    1032. }

    1033. ALCDECL ChinaPYG_waveOutGetErrorTextW(void)
    1034. {
    1035.         JmpAddr((INT64)GetAddress("waveOutGetErrorTextW"));
    1036. }

    1037. ALCDECL ChinaPYG_waveOutGetID(void)
    1038. {
    1039.         JmpAddr((INT64)GetAddress("waveOutGetID"));
    1040. }

    1041. ALCDECL ChinaPYG_waveOutGetNumDevs(void)
    1042. {
    1043.         JmpAddr((INT64)GetAddress("waveOutGetNumDevs"));
    1044. }

    1045. ALCDECL ChinaPYG_waveOutGetPitch(void)
    1046. {
    1047.         JmpAddr((INT64)GetAddress("waveOutGetPitch"));
    1048. }

    1049. ALCDECL ChinaPYG_waveOutGetPlaybackRate(void)
    1050. {
    1051.         JmpAddr((INT64)GetAddress("waveOutGetPlaybackRate"));
    1052. }

    1053. ALCDECL ChinaPYG_waveOutGetPosition(void)
    1054. {
    1055.         JmpAddr((INT64)GetAddress("waveOutGetPosition"));
    1056. }

    1057. ALCDECL ChinaPYG_waveOutGetVolume(void)
    1058. {
    1059.         JmpAddr((INT64)GetAddress("waveOutGetVolume"));
    1060. }

    1061. ALCDECL ChinaPYG_waveOutMessage(void)
    1062. {
    1063.         JmpAddr((INT64)GetAddress("waveOutMessage"));
    1064. }

    1065. ALCDECL ChinaPYG_waveOutOpen(void)
    1066. {
    1067.         JmpAddr((INT64)GetAddress("waveOutOpen"));
    1068. }

    1069. ALCDECL ChinaPYG_waveOutPause(void)
    1070. {
    1071.         JmpAddr((INT64)GetAddress("waveOutPause"));
    1072. }

    1073. ALCDECL ChinaPYG_waveOutPrepareHeader(void)
    1074. {
    1075.         JmpAddr((INT64)GetAddress("waveOutPrepareHeader"));
    1076. }

    1077. ALCDECL ChinaPYG_waveOutReset(void)
    1078. {
    1079.         JmpAddr((INT64)GetAddress("waveOutReset"));
    1080. }

    1081. ALCDECL ChinaPYG_waveOutRestart(void)
    1082. {
    1083.         JmpAddr((INT64)GetAddress("waveOutRestart"));
    1084. }

    1085. ALCDECL ChinaPYG_waveOutSetPitch(void)
    1086. {
    1087.         JmpAddr((INT64)GetAddress("waveOutSetPitch"));
    1088. }

    1089. ALCDECL ChinaPYG_waveOutSetPlaybackRate(void)
    1090. {
    1091.         JmpAddr((INT64)GetAddress("waveOutSetPlaybackRate"));
    1092. }

    1093. ALCDECL ChinaPYG_waveOutSetVolume(void)
    1094. {
    1095.         JmpAddr((INT64)GetAddress("waveOutSetVolume"));
    1096. }

    1097. ALCDECL ChinaPYG_waveOutUnprepareHeader(void)
    1098. {
    1099.         JmpAddr((INT64)GetAddress("waveOutUnprepareHeader"));
    1100. }

    1101. ALCDECL ChinaPYG_waveOutWrite(void)
    1102. {
    1103.         JmpAddr((INT64)GetAddress("waveOutWrite"));
    1104. }

    1105. ALCDECL ChinaPYG_wid32Message(void)
    1106. {
    1107.         JmpAddr((INT64)GetAddress("wid32Message"));
    1108. }

    1109. ALCDECL ChinaPYG_wod32Message(void)
    1110. {
    1111.         JmpAddr((INT64)GetAddress("wod32Message"));
    1112. }
    复制代码


    obj文件源码(用FASMW生成OBJ文件)

    1. format MS64 COFF
    2. ;===================================================
    3. ;" X64 HOOK PiaoYun/P.Y.G"
    4. ;" bbs.chinapyg.com "
    5. ;" www.dllhook.com "
    6. ;===================================================

    7. public JmpAddr
    8. public PatchBYTE
    9. public PatchWORD
    10. public PatchDWORD
    11. public PatchQWORD
    12. public AddFun


    13. JmpAddr:
    14.                 mov     rax, rcx            
    15.                 push    rax                  
    16.                 retn

    17. PatchBYTE:
    18.                 mov     rax, rcx
    19.                 mov     [rax], dl
    20.                 retn            

    21. PatchWORD:
    22.                 mov     rax, rcx     
    23.                 mov     [rax], dx   
    24.                 retn

    25. PatchDWORD:
    26.                 mov     rax, rcx   
    27.                 mov     [rax], edx  
    28.                 retn               

    29. PatchQWORD:
    30.                 mov     rax, rcx  
    31.                 mov     [rax], rdx
    32.                 retn              

    33. AddFun:
    34.                 mov     rax, rcx
    35.                 add     rax, rdx

    36.                 retn
    复制代码


    完全的源码下载【本源码WIN7X64+VS2013测试通过】


    Winmm_X64.rar

    7.55 KB, 下载次数: 123, 下载积分: 飘云币 -2 枚

    售价: 2 枚飘云币  [记录]

    点评

    妹子,老飘这个源码,ASM中JmpAddr的ASM存在BUG,在有调用函数时就会破坏寄存器,导制软件退出!  发表于 2015-6-28 08:35

    评分

    参与人数 3威望 +12 飘云币 +4 收起 理由
    猫子 + 4 PYG有你更精彩!
    wgz001 + 4 + 4 默默地点个赞
    一梦千年缘 + 4 赞一个!

    查看全部评分

    PYG19周年生日快乐!
  • TA的每日心情
    开心
    2022-1-20 17:13
  • 签到天数: 291 天

    [LV.8]以坛为家I

    发表于 2015-6-27 18:27:26 | 显示全部楼层
    赞一个,感觉很不错的样子
    PYG19周年生日快乐!
  • TA的每日心情
    奋斗
    2021-7-17 13:00
  • 签到天数: 975 天

    [LV.10]以坛为家III

    发表于 2015-6-27 18:41:54 | 显示全部楼层
    感谢分享,好像在看天上,膜拜懂编程的大神
    PYG19周年生日快乐!
  • TA的每日心情
    无聊
    2024-3-21 17:38
  • 签到天数: 521 天

    [LV.9]以坛为家II

    发表于 2015-6-27 18:50:48 | 显示全部楼层
    太高级了,我还只是用vs2010
    PYG19周年生日快乐!
  • TA的每日心情
    开心
    2019-2-26 11:14
  • 签到天数: 459 天

    [LV.9]以坛为家II

    发表于 2015-6-27 21:33:19 | 显示全部楼层
    默默地点个赞 {:soso_e179:}
    PYG19周年生日快乐!
  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1266 天

    [LV.10]以坛为家III

    发表于 2015-6-27 22:52:37 | 显示全部楼层
    谢谢分享,,可惜VS版本太高了。。
    PYG19周年生日快乐!
  • TA的每日心情

    昨天 11:45
  • 签到天数: 2142 天

    [LV.Master]伴坛终老

    发表于 2015-6-27 23:31:43 | 显示全部楼层
    {:soso_e195:}
    要是易语言可以编译64位Dll就好了
    PYG19周年生日快乐!
  • TA的每日心情
    开心
    昨天 07:50
  • 签到天数: 2067 天

    [LV.Master]伴坛终老

    发表于 2015-6-28 07:37:54 | 显示全部楼层
    VS2015不知道好不好用?
    PYG19周年生日快乐!
  • TA的每日心情
    无聊
    2024-2-23 08:21
  • 签到天数: 2006 天

    [LV.Master]伴坛终老

    发表于 2015-6-28 09:49:44 | 显示全部楼层
    不管怎么样 支持开源 支持分享
    PYG19周年生日快乐!
  • TA的每日心情
    开心
    昨天 08:48
  • 签到天数: 942 天

    [LV.10]以坛为家III

    发表于 2015-6-28 10:31:29 | 显示全部楼层

    果断MARK,前十有我必火!
    PYG19周年生日快乐!
    您需要登录后才可以回帖 登录 | 加入我们

    本版积分规则

    快速回复 返回顶部 返回列表