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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
win32.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：138k
源码类别：

midi

开发平台：

Unix_Linux

win32.c：源码内容
  1.     printf("CreateWindowEx() called okeyn");
  2.     return 1;
  3. }
  5. static int WINAPI expwaveOutGetNumDevs(void)
  6. {
  7.     dbgprintf("waveOutGetNumDevs() => 0n");
  8.     return 0;
  9. }
  10. #endif
  12. /*
  13.  * Returns the number of milliseconds, modulo 2^32, since the start
  14.  * of the wineserver.
  15.  */
  16. static int WINAPI expGetTickCount(void)
  17. {
  18.     static int tcstart = 0;
  19.     struct timeval t;
  20.     int tc;
  21.     gettimeofday( &t, NULL );
  22.     tc = ((t.tv_sec * 1000) + (t.tv_usec / 1000)) - tcstart;
  23.     if (tcstart == 0)
  24.     {
  25. tcstart = 0;
  26.         tc = 0;
  27.     }
  28.     dbgprintf("GetTickCount() => %dn", tc);
  29.     return tc;
  30. }
  32. static int WINAPI expCreateFontA(void)
  33. {
  34.     dbgprintf("CreateFontA() => 0x0n");
  35.     return 1;
  36. }
  38. /* tried to get pvmjpg work in a different way - no success */
  39. static int WINAPI expDrawTextA(int hDC, char* lpString, int nCount,
  40.        LPRECT lpRect, unsigned int uFormat)
  41. {
  42.     dbgprintf("expDrawTextA(%p,...) => 8n", hDC);
  43.     return 8;
  44. }
  46. static int WINAPI expGetPrivateProfileIntA(const char* appname,
  47.    const char* keyname,
  48.    int default_value,
  49.    const char* filename)
  50. {
  51.     int size=255;
  52.     char buffer[256];
  53.     char* fullname;
  54.     int result;
  56.     buffer[255]=0;
  57.     if(!(appname && keyname && filename) )
  58.     {
  59. dbgprintf("GetPrivateProfileIntA('%s', '%s', %d, '%s') => %dn", appname, keyname, default_value, filename, default_value );
  60. return default_value;
  61.     }
  62.     fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
  63.     strcpy(fullname, "Software\IniFileMapping\");
  64.     strcat(fullname, appname);
  65.     strcat(fullname, "\");
  66.     strcat(fullname, keyname);
  67.     strcat(fullname, "\");
  68.     strcat(fullname, filename);
  69.     result=RegQueryValueExA(HKEY_LOCAL_MACHINE, fullname, NULL, NULL, (int*)buffer, &size);
  70.     if((size>=0)&&(size<256))
  71. buffer[size]=0;
  72.     //    printf("GetPrivateProfileIntA(%s, %s, %s) -> %sn", appname, keyname, filename, buffer);
  73.     free(fullname);
  74.     if(result)
  75. result=default_value;
  76.     else
  77. result=atoi(buffer);
  78.     dbgprintf("GetPrivateProfileIntA('%s', '%s', %d, '%s') => %dn", appname, keyname, default_value, filename, result);
  79.     return result;
  80. }
  81. static int WINAPI expGetProfileIntA(const char* appname,
  82.     const char* keyname,
  83.     int default_value)
  84. {
  85.     dbgprintf("GetProfileIntA -> ");
  86.     return expGetPrivateProfileIntA(appname, keyname, default_value, "default");
  87. }
  89. static int WINAPI expGetPrivateProfileStringA(const char* appname,
  90.       const char* keyname,
  91.       const char* def_val,
  92.       char* dest, unsigned int len,
  93.       const char* filename)
  94. {
  95.     int result;
  96.     int size;
  97.     char* fullname;
  98.     dbgprintf("GetPrivateProfileStringA('%s', '%s', def_val '%s', 0x%x, 0x%x, '%s')", appname, keyname, def_val, dest, len, filename );
  99.     if(!(appname && keyname && filename) ) return 0;
  100.     fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
  101.     strcpy(fullname, "Software\IniFileMapping\");
  102.     strcat(fullname, appname);
  103.     strcat(fullname, "\");
  104.     strcat(fullname, keyname);
  105.     strcat(fullname, "\");
  106.     strcat(fullname, filename);
  107.     size=len;
  108.     result=RegQueryValueExA(HKEY_LOCAL_MACHINE, fullname, NULL, NULL, (int*)dest, &size);
  109.     free(fullname);
  110.     if(result)
  111.     {
  112. strncpy(dest, def_val, size);
  113. if (strlen(def_val)< size) size = strlen(def_val);
  114.     }
  115.     dbgprintf(" => %d ( '%s' )n", size, dest);
  116.     return size;
  117. }
  118. static int WINAPI expWritePrivateProfileStringA(const char* appname,
  119. const char* keyname,
  120. const char* string,
  121. const char* filename)
  122. {
  123.     int size=256;
  124.     char* fullname;
  125.     dbgprintf("WritePrivateProfileStringA('%s', '%s', '%s', '%s')", appname, keyname, string, filename );
  126.     if(!(appname && keyname && filename) )
  127.     {
  128. dbgprintf(" => -1n");
  129. return -1;
  130.     }
  131.     fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
  132.     strcpy(fullname, "Software\IniFileMapping\");
  133.     strcat(fullname, appname);
  134.     strcat(fullname, "\");
  135.     strcat(fullname, keyname);
  136.     strcat(fullname, "\");
  137.     strcat(fullname, filename);
  138.     RegSetValueExA(HKEY_LOCAL_MACHINE, fullname, 0, REG_SZ, (int*)string, strlen(string));
  139.     //    printf("RegSetValueExA(%s,%d)n", string, strlen(string));
  140.     //    printf("WritePrivateProfileStringA(%s, %s, %s, %s)n", appname, keyname, string, filename );
  141.     free(fullname);
  142.     dbgprintf(" => 0n");
  143.     return 0;
  144. }
  146. unsigned int _GetPrivateProfileIntA(const char* appname, const char* keyname, INT default_value, const char* filename)
  147. {
  148.     return expGetPrivateProfileIntA(appname, keyname, default_value, filename);
  149. }
  150. int _GetPrivateProfileStringA(const char* appname, const char* keyname,
  151.       const char* def_val, char* dest, unsigned int len, const char* filename)
  152. {
  153.     return expGetPrivateProfileStringA(appname, keyname, def_val, dest, len, filename);
  154. }
  155. int _WritePrivateProfileStringA(const char* appname, const char* keyname,
  156. const char* string, const char* filename)
  157. {
  158.     return expWritePrivateProfileStringA(appname, keyname, string, filename);
  159. }
  163. static int WINAPI expDefDriverProc(int _private, int id, int msg, int arg1, int arg2)
  164. {
  165.     dbgprintf("DefDriverProc(0x%x, 0x%x, 0x%x, 0x%x, 0x%x) => 0n", _private, id, msg, arg1, arg2);
  166.     return 0;
  167. }
  169. static int WINAPI expSizeofResource(int v1, int v2)
  170. {
  171.     int result=SizeofResource(v1, v2);
  172.     dbgprintf("SizeofResource(0x%x, 0x%x) => %dn", v1, v2, result);
  173.     return result;
  174. }
  176. static int WINAPI expGetLastError()
  177. {
  178.     int result=GetLastError();
  179.     dbgprintf("GetLastError() => 0x%xn", result);
  180.     return result;
  181. }
  183. static void WINAPI expSetLastError(int error)
  184. {
  185.     dbgprintf("SetLastError(0x%x)n", error);
  186.     SetLastError(error);
  187. }
  189. static int WINAPI expStringFromGUID2(GUID* guid, char* str, int cbMax)
  190. {
  191.     int result=snprintf(str, cbMax, "%.8x-%.4x-%.4x-%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
  192. guid->f1, guid->f2, guid->f3,
  193. (unsigned char)guid->f4[0], (unsigned char)guid->f4[1],
  194. (unsigned char)guid->f4[2], (unsigned char)guid->f4[3],
  195. (unsigned char)guid->f4[4], (unsigned char)guid->f4[5],
  196. (unsigned char)guid->f4[6], (unsigned char)guid->f4[7]);
  197.     dbgprintf("StringFromGUID2(0x%x, 0x%x='%s', %d) => %dn", guid, str, str, cbMax, result);
  198.     return result;
  199. }
  202. static int WINAPI expGetFileVersionInfoSizeA(const char* name, int* lpHandle)
  203. {
  204.     dbgprintf("GetFileVersionInfoSizeA(0x%x='%s', 0x%X) => 0n", name, name, lpHandle);
  205.     return 0;
  206. }
  208. static int WINAPI expIsBadStringPtrW(const short* string, int nchars)
  209. {
  210.     int result;
  211.     if(string==0)result=1; else result=0;
  212.     dbgprintf("IsBadStringPtrW(0x%x, %d) => %d", string, nchars, result);
  213.     if(string)wch_print(string);
  214.     return result;
  215. }
  216. static int WINAPI expIsBadStringPtrA(const char* string, int nchars)
  217. {
  218.     return expIsBadStringPtrW((const short*)string, nchars);
  219. }
  220. static long WINAPI expInterlockedExchangeAdd( long* dest, long incr )
  221. {
  222.     long ret;
  223.     __asm__ __volatile__
  224. (
  225.  "lock; xaddl %0,(%1)"
  226.  : "=r" (ret)
  227.  : "r" (dest), "0" (incr)
  228.  : "memory"
  229. );
  230.     return ret;
  231. }
  233. static long WINAPI expInterlockedCompareExchange( unsigned long* dest, unsigned long exchange, unsigned long comperand)
  234. {
  235.     unsigned long retval = *dest;
  236.     if(*dest == comperand)
  237. *dest = exchange;
  238.     return retval;
  239. }
  241. static long WINAPI expInterlockedIncrement( long* dest )
  242. {
  243.     long result=expInterlockedExchangeAdd( dest, 1 ) + 1;
  244.     dbgprintf("InterlockedIncrement(0x%x => %d) => %dn", dest, *dest, result);
  245.     return result;
  246. }
  247. static long WINAPI expInterlockedDecrement( long* dest )
  248. {
  249.     long result=expInterlockedExchangeAdd( dest, -1 ) - 1;
  250.     dbgprintf("InterlockedDecrement(0x%x => %d) => %dn", dest, *dest, result);
  251.     return result;
  252. }
  254. static void WINAPI expOutputDebugStringA( const char* string )
  255. {
  256.     dbgprintf("OutputDebugStringA(0x%x='%s')n", string);
  257.     fprintf(stderr, "DEBUG: %sn", string);
  258. }
  260. static int WINAPI expGetDC(int hwnd)
  261. {
  262.     dbgprintf("GetDC(0x%x) => 1n", hwnd);
  263.     return 1;
  264. }
  266. static int WINAPI expReleaseDC(int hwnd, int hdc)
  267. {
  268.     dbgprintf("ReleaseDC(0x%x, 0x%x) => 1n", hwnd, hdc);
  269.     return 1;
  270. }
  272. static int WINAPI expGetDesktopWindow()
  273. {
  274.     dbgprintf("GetDesktopWindow() => 0n");
  275.     return 0;
  276. }
  278. static int cursor[100];
  280. static int WINAPI expLoadCursorA(int handle,LPCSTR name)
  281. {
  282.     dbgprintf("LoadCursorA(%d, 0x%x='%s') => 0x%xn", handle, name, (int)&cursor[0]);
  283.     return (int)&cursor[0];
  284. }
  285. static int WINAPI expSetCursor(void *cursor)
  286. {
  287.     dbgprintf("SetCursor(0x%x) => 0x%xn", cursor, cursor);
  288.     return (int)cursor;
  289. }
  290. static int WINAPI expGetCursorPos(void *cursor)
  291. {
  292.     dbgprintf("GetCursorPos(0x%x) => 0x%xn", cursor, cursor);
  293.     return 1;
  294. }
  295. #ifdef QTX
  296. static int show_cursor = 0;
  297. static int WINAPI expShowCursor(int show)
  298. {
  299.     dbgprintf("ShowCursor(%d) => %dn", show, show);
  300.     if (show)
  301. show_cursor++;
  302.     else
  303. show_cursor--;
  304.     return show_cursor;
  305. }
  306. #endif
  307. static int WINAPI expRegisterWindowMessageA(char *message)
  308. {
  309.     dbgprintf("RegisterWindowMessageA(%s)n", message);
  310.     return 1;
  311. }
  312. static int WINAPI expGetProcessVersion(int pid)
  313. {
  314.     dbgprintf("GetProcessVersion(%d)n", pid);
  315.     return 1;
  316. }
  317. static int WINAPI expGetCurrentThread(void)
  318. {
  319. #warning FIXME!
  320.     dbgprintf("GetCurrentThread() => %xn", 0xcfcf9898);
  321.     return 0xcfcf9898;
  322. }
  323. static int WINAPI expGetOEMCP(void)
  324. {
  325.     dbgprintf("GetOEMCP()n");
  326.     return 1;
  327. }
  328. static int WINAPI expGetCPInfo(int cp,void *info)
  329. {
  330.     dbgprintf("GetCPInfo()n");
  331.     return 0;
  332. }
  333. #ifdef QTX
  334. #define SM_CXSCREEN 0
  335. #define SM_CYSCREEN 1
  336. #define SM_XVIRTUALSCREEN 76
  337. #define SM_YVIRTUALSCREEN 77
  338. #define SM_CXVIRTUALSCREEN  78
  339. #define SM_CYVIRTUALSCREEN 79
  340. #define SM_CMONITORS 80
  341. #endif
  342. static int WINAPI expGetSystemMetrics(int index)
  343. {
  344.     dbgprintf("GetSystemMetrics(%d)n", index);
  345. #ifdef QTX
  346.     switch(index)
  347.     {
  348. case SM_XVIRTUALSCREEN:
  349. case SM_YVIRTUALSCREEN:
  350.     return 0;
  351. case SM_CXSCREEN:
  352. case SM_CXVIRTUALSCREEN:
  353.     return PSEUDO_SCREEN_WIDTH;
  354. case SM_CYSCREEN:
  355. case SM_CYVIRTUALSCREEN:
  356.     return PSEUDO_SCREEN_HEIGHT;
  357. case SM_CMONITORS:
  358.     return 1;
  359.     }
  360. #endif
  361.     return 1;
  362. }
  363. static int WINAPI expGetSysColor(int index)
  364. {
  365.     dbgprintf("GetSysColor(%d) => 1n", index);
  366.     return 1;
  367. }
  368. static int WINAPI expGetSysColorBrush(int index)
  369. {
  370.     dbgprintf("GetSysColorBrush(%d)n", index);
  371.     return 1;
  372. }
  376. static int WINAPI expGetSystemPaletteEntries(int hdc, int iStartIndex, int nEntries, void* lppe)
  377. {
  378.     dbgprintf("GetSystemPaletteEntries(0x%x, 0x%x, 0x%x, 0x%x) => 0n",
  379.       hdc, iStartIndex, nEntries, lppe);
  380.     return 0;
  381. }
  383. /*
  384.  typedef struct _TIME_ZONE_INFORMATION {
  385.  long Bias;
  386.  char StandardName[32];
  387.  SYSTEMTIME StandardDate;
  388.  long StandardBias;
  389.  char DaylightName[32];
  390.  SYSTEMTIME DaylightDate;
  391.  long DaylightBias;
  392.  } TIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;
  393.  */
  395. static int WINAPI expGetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation)
  396. {
  397.     const short name[]={'C', 'e', 'n', 't', 'r', 'a', 'l', ' ', 'S', 't', 'a',
  398.     'n', 'd', 'a', 'r', 'd', ' ', 'T', 'i', 'm', 'e', 0};
  399.     const short pname[]={'C', 'e', 'n', 't', 'r', 'a', 'l', ' ', 'D', 'a', 'y',
  400.     'l', 'i', 'g', 'h', 't', ' ', 'T', 'i', 'm', 'e', 0};
  401.     dbgprintf("GetTimeZoneInformation(0x%x) => TIME_ZONE_ID_STANDARDn");
  402.     memset(lpTimeZoneInformation, 0, sizeof(TIME_ZONE_INFORMATION));
  403.     lpTimeZoneInformation->Bias=360;//GMT-6
  404.     memcpy(lpTimeZoneInformation->StandardName, name, sizeof(name));
  405.     lpTimeZoneInformation->StandardDate.wMonth=10;
  406.     lpTimeZoneInformation->StandardDate.wDay=5;
  407.     lpTimeZoneInformation->StandardDate.wHour=2;
  408.     lpTimeZoneInformation->StandardBias=0;
  409.     memcpy(lpTimeZoneInformation->DaylightName, pname, sizeof(pname));
  410.     lpTimeZoneInformation->DaylightDate.wMonth=4;
  411.     lpTimeZoneInformation->DaylightDate.wDay=1;
  412.     lpTimeZoneInformation->DaylightDate.wHour=2;
  413.     lpTimeZoneInformation->DaylightBias=-60;
  414.     return TIME_ZONE_ID_STANDARD;
  415. }
  417. static void WINAPI expGetLocalTime(SYSTEMTIME* systime)
  418. {
  419.     time_t local_time;
  420.     struct tm *local_tm;
  421.     struct timeval tv;
  423.     dbgprintf("GetLocalTime(0x%x)n");
  424.     gettimeofday(&tv, NULL);
  425.     local_time=tv.tv_sec;
  426.     local_tm=localtime(&local_time);
  428.     systime->wYear = local_tm->tm_year + 1900;
  429.     systime->wMonth = local_tm->tm_mon + 1;
  430.     systime->wDayOfWeek = local_tm->tm_wday;
  431.     systime->wDay = local_tm->tm_mday;
  432.     systime->wHour = local_tm->tm_hour;
  433.     systime->wMinute = local_tm->tm_min;
  434.     systime->wSecond = local_tm->tm_sec;
  435.     systime->wMilliseconds = (tv.tv_usec / 1000) % 1000;
  436.     dbgprintf("  Year: %dn  Month: %dn  Day of week: %dn"
  437.       "  Day: %dn  Hour: %dn  Minute: %dn  Second:  %dn"
  438.       "  Milliseconds: %dn",
  439.       systime->wYear, systime->wMonth, systime->wDayOfWeek, systime->wDay,
  440.       systime->wHour, systime->wMinute, systime->wSecond, systime->wMilliseconds);
  441. }
  443. static int WINAPI expGetSystemTime(SYSTEMTIME* systime)
  444. {
  445.     time_t local_time;
  446.     struct tm *local_tm;
  447.     struct timeval tv;
  449.     dbgprintf("GetSystemTime(0x%x)n", systime);
  450.     gettimeofday(&tv, NULL);
  451.     local_time=tv.tv_sec;
  452.     local_tm=gmtime(&local_time);
  454.     systime->wYear = local_tm->tm_year + 1900;
  455.     systime->wMonth = local_tm->tm_mon + 1;
  456.     systime->wDayOfWeek = local_tm->tm_wday;
  457.     systime->wDay = local_tm->tm_mday;
  458.     systime->wHour = local_tm->tm_hour;
  459.     systime->wMinute = local_tm->tm_min;
  460.     systime->wSecond = local_tm->tm_sec;
  461.     systime->wMilliseconds = (tv.tv_usec / 1000) % 1000;
  462.     dbgprintf("  Year: %dn  Month: %dn  Day of week: %dn"
  463.       "  Day: %dn  Hour: %dn  Minute: %dn  Second:  %dn"
  464.       "  Milliseconds: %dn",
  465.       systime->wYear, systime->wMonth, systime->wDayOfWeek, systime->wDay,
  466.       systime->wHour, systime->wMinute, systime->wSecond, systime->wMilliseconds);
  467.     return 0;
  468. }
  470. #define SECS_1601_TO_1970  ((369 * 365 + 89) * 86400ULL)
  471. static void WINAPI expGetSystemTimeAsFileTime(FILETIME* systime)
  472. {
  473.     struct tm *local_tm;
  474.     struct timeval tv;
  475.     unsigned long long secs;
  477.     dbgprintf("GetSystemTime(0x%x)n", systime);
  478.     gettimeofday(&tv, NULL);
  479.     secs = (tv.tv_sec + SECS_1601_TO_1970) * 10000000;
  480.     secs += tv.tv_usec * 10;
  481.     systime->dwLowDateTime = secs & 0xffffffff;
  482.     systime->dwHighDateTime = (secs >> 32);
  483. }
  485. static int WINAPI expGetEnvironmentVariableA(const char* name, char* field, int size)
  486. {
  487.     char *p;
  488.     //    printf("%s %x %xn", name, field, size);
  489.     if(field)field[0]=0;
  490.     /*
  491.      p = getenv(name);
  492.      if (p) strncpy(field,p,size);
  493.      */
  494.     if (strcmp(name,"__MSVCRT_HEAP_SELECT")==0)
  495. strcpy(field,"__GLOBAL_HEAP_SELECTED,1");
  496.     dbgprintf("GetEnvironmentVariableA(0x%x='%s', 0x%x, %d) => %dn", name, name, field, size, strlen(field));
  497.     return strlen(field);
  498. }
  500. static int WINAPI expSetEnvironmentVariableA(const char *name, const char *value)
  501. {
  502.     dbgprintf("SetEnvironmentVariableA(%s, %s)n", name, value);
  503.     return 0;
  504. }
  506. static void* WINAPI expCoTaskMemAlloc(ULONG cb)
  507. {
  508.     return my_mreq(cb, 0);
  509. }
  510. static void WINAPI expCoTaskMemFree(void* cb)
  511. {
  512.     my_release(cb);
  513. }
  518. void* CoTaskMemAlloc(unsigned long cb)
  519. {
  520.     return expCoTaskMemAlloc(cb);
  521. }
  522. void CoTaskMemFree(void* cb)
  523. {
  524.     expCoTaskMemFree(cb);
  525. }
  527. struct COM_OBJECT_INFO
  528. {
  529.     GUID clsid;
  530.     long (*GetClassObject) (GUID* clsid, const GUID* iid, void** ppv);
  531. };
  533. static struct COM_OBJECT_INFO* com_object_table=0;
  534. static int com_object_size=0;
  535. int RegisterComClass(const GUID* clsid, GETCLASSOBJECT gcs)
  536. {
  537.     if(!clsid || !gcs)
  538. return -1;
  539.     com_object_table=realloc(com_object_table, sizeof(struct COM_OBJECT_INFO)*(++com_object_size));
  540.     com_object_table[com_object_size-1].clsid=*clsid;
  541.     com_object_table[com_object_size-1].GetClassObject=gcs;
  542.     return 0;
  543. }
  545. int UnregisterComClass(const GUID* clsid, GETCLASSOBJECT gcs)
  546. {
  547.     int found = 0;
  548.     int i = 0;
  549.     if(!clsid || !gcs)
  550. return -1;
  552.     if (com_object_table == 0)
  553. printf("Warning: UnregisterComClass() called without any registered classn");
  554.     while (i < com_object_size)
  555.     {
  556. if (found && i > 0)
  557. {
  558.     memcpy(&com_object_table[i - 1].clsid,
  559.    &com_object_table[i].clsid, sizeof(GUID));
  560.     com_object_table[i - 1].GetClassObject =
  561. com_object_table[i].GetClassObject;
  562. }
  563. else if (memcmp(&com_object_table[i].clsid, clsid, sizeof(GUID)) == 0
  564.  && com_object_table[i].GetClassObject == gcs)
  565. {
  566.     found++;
  567. }
  568. i++;
  569.     }
  570.     if (found)
  571.     {
  572. if (--com_object_size == 0)
  573. {
  574.     free(com_object_table);
  575.     com_object_table = 0;
  576. }
  577.     }
  578.     return 0;
  579. }
  582. const GUID IID_IUnknown =
  583. {
  584.     0x00000000, 0x0000, 0x0000,
  585.     {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}
  586. };
  587. const GUID IID_IClassFactory =
  588. {
  589.     0x00000001, 0x0000, 0x0000,
  590.     {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}
  591. };
  593. static long WINAPI expCoCreateInstance(GUID* rclsid, struct IUnknown* pUnkOuter,
  594.        long dwClsContext, const GUID* riid, void** ppv)
  595. {
  596.     int i;
  597.     struct COM_OBJECT_INFO* ci=0;
  598.     for(i=0; i<com_object_size; i++)
  599. if(!memcmp(rclsid, &com_object_table[i].clsid, sizeof(GUID)))
  600.     ci=&com_object_table[i];
  601.     if(!ci)return REGDB_E_CLASSNOTREG;
  602.     // in 'real' world we should mess with IClassFactory here
  603.     i=ci->GetClassObject(rclsid, riid, ppv);
  604.     return i;
  605. }
  607. long CoCreateInstance(GUID* rclsid, struct IUnknown* pUnkOuter,
  608.       long dwClsContext, const GUID* riid, void** ppv)
  609. {
  610.     return expCoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv);
  611. }
  613. static int WINAPI expIsRectEmpty(CONST RECT *lprc)
  614. {
  615.     int r = 0;
  616.     int w,h;
  617. //trapbug();
  618.     if (lprc)
  619.     {
  620. w = lprc->right - lprc->left;
  621. h = lprc->bottom - lprc->top;
  622. if (w <= 0 || h <= 0)
  623.     r = 1;
  624.     }
  625.     else
  626. r = 1;
  628.     dbgprintf("IsRectEmpty(%p) => %sn", lprc, (r) ? "TRUE" : "FALSE");
  629.     //printf("Rect: left: %d, top: %d, right: %d, bottom: %dn", lprc->left, lprc->top, lprc->right, lprc->bottom);
  630. //    return 0; // wmv9?
  631.     return r; // TM20
  632. }
  634. static int _adjust_fdiv=0; //what's this? - used to adjust division
  639. static unsigned int WINAPI expGetTempPathA(unsigned int len, char* path)
  640. {
  641.     dbgprintf("GetTempPathA(%d, 0x%x)", len, path);
  642.     if(len<5)
  643.     {
  644. dbgprintf(" => 0n");
  645. return 0;
  646.     }
  647.     strcpy(path, "/tmp");
  648.     dbgprintf(" => 5 ( '/tmp' )n");
  649.     return 5;
  650. }
  651. /*
  652.  FYI:
  653.  typedef struct
  654.  {
  655.  DWORD     dwFileAttributes;
  656.  FILETIME  ftCreationTime;
  657.  FILETIME  ftLastAccessTime;
  658.  FILETIME  ftLastWriteTime;
  659.  DWORD     nFileSizeHigh;
  660.  DWORD     nFileSizeLow;
  661.  DWORD     dwReserved0;
  662.  DWORD     dwReserved1;
  663.  CHAR      cFileName[260];
  664.  CHAR      cAlternateFileName[14];
  665.  } WIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
  666.  */
  668. static DIR* qtx_dir=NULL;
  670. static WIN_BOOL WINAPI expFindNextFileA(HANDLE h,LPWIN32_FIND_DATAA lpfd)
  671. {
  672. #ifdef QTX
  673.     dbgprintf("FindNextFileA(0x%x, 0x%x) => 0n", h, lpfd);
  674.     if(h==FILE_HANDLE_quicktimeqtx){
  675. struct dirent* d;
  676. if(!qtx_dir) return 0;
  677. while((d=readdir(qtx_dir))){
  678.     char* x=strrchr(d->d_name,'.');
  679.     if(!x) continue;
  680.     if(strcmp(x,".qtx")) continue;
  681.     strcpy(lpfd->cFileName,d->d_name);
  682. //     sprintf(lpfd->cAlternateFileName,"%-8s.qtx",d->d_name);
  683.     strcpy(lpfd->cAlternateFileName,"foobar.qtx");
  684.     printf("### FindNext: %sn",lpfd->cFileName);
  685.     return 1;
  686. }
  687. closedir(qtx_dir); qtx_dir=NULL;
  688. return 0;
  689.     }
  690. #endif
  691.     return 0;
  692. }
  694. static HANDLE WINAPI expFindFirstFileA(LPCSTR s, LPWIN32_FIND_DATAA lpfd)
  695. {
  696.     dbgprintf("FindFirstFileA(0x%x='%s', 0x%x) => 0n", s, s, lpfd);
  697. //    printf("n### FindFirstFileA('%s')...n",s);
  698. #ifdef QTX
  699.     if(strstr(s, "quicktime\*.QTX")){
  700. dbgprintf("FindFirstFileA(0x%x='%s', 0x%x) => QTXn", s, s, lpfd);
  701. printf("n### Searching for QuickTime plugins (*.qtx) at %s...n",def_path);
  702. qtx_dir=opendir(def_path);
  703. if(!qtx_dir) return (HANDLE)-1;
  704. memset(lpfd,0,sizeof(*lpfd));
  705. if(expFindNextFileA(FILE_HANDLE_quicktimeqtx,lpfd))
  706.     return FILE_HANDLE_quicktimeqtx;
  707. printf("loader: Couldn't find the QuickTime plugins (.qtx files) at %sn",def_path);
  708. return (HANDLE)-1;
  709.     }
  710. #if 0
  711.     if(strstr(s, "QuickTime.qts")){
  712. dbgprintf("FindFirstFileA(0x%x='%s', 0x%x) => QTSn", s, s, lpfd);
  713. // if(!strcmp(s,"C:\windows\QuickTime.qts\QuickTime.qts\*.QTX"))
  714. //     return (HANDLE)-1;
  715. strcpy(lpfd->cFileName, "QuickTime.qts");
  716. strcpy(lpfd->cAlternateFileName, "QuickT~1.qts");
  717. return FILE_HANDLE_quicktimeqts;
  718.     }
  719. #endif
  720. #endif
  721.     if(strstr(s, "*.vwp")){
  722. // hack for VoxWare codec plugins:
  723. strcpy(lpfd->cFileName, "msms001.vwp");
  724. strcpy(lpfd->cAlternateFileName, "msms001.vwp");
  725. return (HANDLE)0;
  726.     }
  727.     // return 'file not found'
  728.     return (HANDLE)-1;
  729. }
  731. static WIN_BOOL WINAPI expFindClose(HANDLE h)
  732. {
  733.     dbgprintf("FindClose(0x%x) => 0n", h);
  734. #ifdef QTX
  735. //    if(h==FILE_HANDLE_quicktimeqtx && qtx_dir){
  736. // closedir(qtx_dir);
  737. // qtx_dir=NULL;
  738. //    }
  739. #endif
  740.     return 0;
  741. }
  742. static UINT WINAPI expSetErrorMode(UINT i)
  743. {
  744.     dbgprintf("SetErrorMode(%d) => 0n", i);
  745.     return 0;
  746. }
  747. static UINT WINAPI expGetWindowsDirectoryA(LPSTR s,UINT c)
  748. {
  749.     char windir[]="c:\windows";
  750.     int result;
  751.     strncpy(s, windir, c);
  752.     result=1+((c<strlen(windir))?c:strlen(windir));
  753.     dbgprintf("GetWindowsDirectoryA(0x%x, %d) => %dn", s, c, result);
  754.     return result;
  755. }
  756. #ifdef QTX
  757. static UINT WINAPI expGetCurrentDirectoryA(UINT c, LPSTR s)
  758. {
  759.     char curdir[]="c:\";
  760.     int result;
  761.     strncpy(s, curdir, c);
  762.     result=1+((c<strlen(curdir))?c:strlen(curdir));
  763.     dbgprintf("GetCurrentDirectoryA(0x%x, %d) => %dn", s, c, result);
  764.     return result;
  765. }
  767. static int WINAPI expSetCurrentDirectoryA(const char *pathname)
  768. {
  769.     dbgprintf("SetCurrentDirectoryA(0x%x = %s) => 1n", pathname, pathname);
  770. #if 0
  771.     if (strrchr(pathname, '\'))
  772. chdir(strcat(strrchr(pathname, '\')+1, '/'));
  773.     else
  774. chdir(pathname);
  775. #endif
  776.     return 1;
  777. }
  779. static int WINAPI expCreateDirectoryA(const char *pathname, void *sa)
  780. {
  781.     dbgprintf("CreateDirectory(0x%x = %s, 0x%x) => 1n",
  782. pathname, pathname, sa);
  783. #if 0
  784.     p = strrchr(pathname, '\')+1;
  785.     strcpy(&buf[0], p); /* should be strncpy */
  786.     if (!strlen(p))
  787.     {
  788. buf[0] = '.';
  789. buf[1] = 0;
  790.     }
  791. #if 0    
  792.     if (strrchr(pathname, '\'))
  793. mkdir(strcat(strrchr(pathname, '\')+1, '/'), 666);
  794.     else
  795. mkdir(pathname, 666);
  796. #endif
  797.     mkdir(&buf);
  798. #endif
  799.     return 1;
  800. }
  801. #endif
  802. static WIN_BOOL  WINAPI expDeleteFileA(LPCSTR s)
  803. {
  804.     dbgprintf("DeleteFileA(0x%x='%s') => 0n", s, s);
  805.     return 0;
  806. }
  807. static WIN_BOOL  WINAPI expFileTimeToLocalFileTime(const FILETIME* cpf, LPFILETIME pf)
  808. {
  809.     dbgprintf("FileTimeToLocalFileTime(0x%x, 0x%x) => 0n", cpf, pf);
  810.     return 0;
  811. }
  813. static UINT WINAPI expGetTempFileNameA(LPCSTR cs1,LPCSTR cs2,UINT i,LPSTR ps)
  814. {
  815.     char mask[16]="/tmp/AP_XXXXXX";
  816.     int result;
  817.     dbgprintf("GetTempFileNameA(0x%x='%s', 0x%x='%s', %d, 0x%x)", cs1, cs1, cs2, cs2, i, ps);
  818.     if(i && i<10)
  819.     {
  820. dbgprintf(" => -1n");
  821. return -1;
  822.     }
  823.     result=mkstemp(mask);
  824.     sprintf(ps, "AP%d", result);
  825.     dbgprintf(" => %dn", strlen(ps));
  826.     return strlen(ps);
  827. }
  828. //
  829. // This func might need proper implementation if we want AngelPotion codec.
  830. // They try to open APmpeg4v1.apl with it.
  831. // DLL will close opened file with CloseHandle().
  832. //
  833. static HANDLE WINAPI expCreateFileA(LPCSTR cs1,DWORD i1,DWORD i2,
  834.     LPSECURITY_ATTRIBUTES p1, DWORD i3,DWORD i4,HANDLE i5)
  835. {
  836.     dbgprintf("CreateFileA(0x%x='%s', %d, %d, 0x%x, %d, %d, 0x%x)n", cs1, cs1, i1,
  837.       i2, p1, i3, i4, i5);
  838.     if((!cs1) || (strlen(cs1)<2))return -1;
  840. #ifdef QTX
  841.     if(strstr(cs1, "QuickTime.qts"))
  842.     {
  843. int result;
  844. char* tmp=(char*)malloc(strlen(def_path)+50);
  845. strcpy(tmp, def_path);
  846. strcat(tmp, "/");
  847. strcat(tmp, "QuickTime.qts");
  848. result=open(tmp, O_RDONLY);
  849. free(tmp);
  850. return result;
  851.     }
  852.     if(strstr(cs1, ".qtx"))
  853.     {
  854. int result;
  855. char* tmp=(char*)malloc(strlen(def_path)+250);
  856. char* x=strrchr(cs1,'\');
  857. sprintf(tmp,"%s/%s",def_path,x?(x+1):cs1);
  858. // printf("### Open: %s -> %sn",cs1,tmp);
  859. result=open(tmp, O_RDONLY);
  860. free(tmp);
  861. return result;
  862.     }
  863. #endif
  865.     if(strncmp(cs1, "AP", 2) == 0)
  866.     {
  867. int result;
  868. char* tmp=(char*)malloc(strlen(def_path)+50);
  869. strcpy(tmp, def_path);
  870. strcat(tmp, "/");
  871. strcat(tmp, "APmpg4v1.apl");
  872. result=open(tmp, O_RDONLY);
  873. free(tmp);
  874. return result;
  875.     }
  876.     if (strstr(cs1, "vp3"))
  877.     {
  878. int r;
  879. int flg = 0;
  880. char* tmp=(char*)malloc(20 + strlen(cs1));
  881. strcpy(tmp, "/tmp/");
  882. strcat(tmp, cs1);
  883. r = 4;
  884. while (tmp[r])
  885. {
  886.     if (tmp[r] == ':' || tmp[r] == '\')
  887. tmp[r] = '_';
  888.     r++;
  889. }
  890. if (GENERIC_READ & i1)
  891.     flg |= O_RDONLY;
  892. else if (GENERIC_WRITE & i1)
  893. {
  894.     flg |= O_WRONLY;
  895.     printf("Warning: openning filename %s  %d (flags; 0x%x) for writen", tmp, r, flg);
  896. }
  897. r=open(tmp, flg);
  898. free(tmp);
  899. return r;
  900.     }
  902.     // Needed by wnvplay1.dll
  903.     if (strstr(cs1, "WINNOV.bmp"))
  904.     {
  905. int r;
  906. r=open("/dev/null", 0);
  907. return r;
  908.     }
  910. #if 0
  911.     /* we need this for some virtualdub filters */
  912.     {
  913. int r;
  914. int flg = 0;
  915. if (GENERIC_READ & i1)
  916.     flg |= O_RDONLY;
  917. else if (GENERIC_WRITE & i1)
  918. {
  919.     flg |= O_WRONLY;
  920.     printf("Warning: openning filename %s  %d (flags; 0x%x) for writen", cs1, r, flg);
  921. }
  922. r=open(cs1, flg);
  923. return r;
  924.     }
  925. #endif
  927.     return atoi(cs1+2);
  928. }
  929. static UINT WINAPI expGetSystemDirectoryA(
  930.   char* lpBuffer,  // address of buffer for system directory
  931.   UINT uSize        // size of directory buffer
  932. ){
  933.     dbgprintf("GetSystemDirectoryA(%p,%d)n", lpBuffer,uSize);
  934.     if(!lpBuffer) strcpy(lpBuffer,".");
  935.     return 1;
  936. }
  937. /*
  938. static char sysdir[]=".";
  939. static LPCSTR WINAPI expGetSystemDirectoryA()
  940. {
  941.     dbgprintf("GetSystemDirectoryA() => 0x%x='%s'n", sysdir, sysdir);
  942.     return sysdir;
  943. }
  944. */
  945. static DWORD WINAPI expGetFullPathNameA
  946. (
  947. LPCTSTR lpFileName,
  948. DWORD nBufferLength,
  949. LPTSTR lpBuffer,
  950. LPTSTR lpFilePart
  951. ){
  952.     if(!lpFileName) return 0;
  953.     dbgprintf("GetFullPathNameA('%s',%d,%p,%p)n",lpFileName,nBufferLength,
  954. lpBuffer, lpFilePart);
  955. #if 0
  956. #ifdef QTX
  957.     strcpy(lpFilePart, "Quick123.qts");
  958. #else
  959.     strcpy(lpFilePart, lpFileName);
  960. #endif
  961. #else
  962.     if (strrchr(lpFileName, '\'))
  963. lpFilePart = strrchr(lpFileName, '\');
  964.     else
  965. lpFilePart = (LPTSTR)lpFileName;
  966. #endif
  967.     strcpy(lpBuffer, lpFileName);
  968. //    strncpy(lpBuffer, lpFileName, rindex(lpFileName, '\')-lpFileName);
  969.     return strlen(lpBuffer);
  970. }
  972. static DWORD WINAPI expGetShortPathNameA
  973. (
  974.         LPCSTR longpath,
  975.         LPSTR shortpath,
  976.         DWORD shortlen
  977. ){
  978.     if(!longpath) return 0;
  979.     dbgprintf("GetShortPathNameA('%s',%p,%d)n",longpath,shortpath,shortlen);
  980.     strcpy(shortpath,longpath);
  981.     return strlen(shortpath);
  982. }
  984. static WIN_BOOL WINAPI expReadFile(HANDLE h,LPVOID pv,DWORD size,LPDWORD rd,LPOVERLAPPED unused)
  985. {
  986.     int result;
  987.     dbgprintf("ReadFile(%d, 0x%x, %d -> 0x%x)n", h, pv, size, rd);
  988.     result=read(h, pv, size);
  989.     if(rd)*rd=result;
  990.     if(!result)return 0;
  991.     return 1;
  992. }
  994. static WIN_BOOL WINAPI expWriteFile(HANDLE h,LPCVOID pv,DWORD size,LPDWORD wr,LPOVERLAPPED unused)
  995. {
  996.     int result;
  997.     dbgprintf("WriteFile(%d, 0x%x, %d -> 0x%x)n", h, pv, size, wr);
  998.     if(h==1234)h=1;
  999.     result=write(h, pv, size);
  1000.     if(wr)*wr=result;
  1001.     if(!result)return 0;
  1002.     return 1;
  1003. }
  1004. static DWORD  WINAPI expSetFilePointer(HANDLE h, LONG val, LPLONG ext, DWORD whence)
  1005. {
  1006.     int wh;
  1007.     dbgprintf("SetFilePointer(%d, 0x%x, 0x%x = %d, %d)n", h, val, ext, *ext, whence);
  1008.     //why would DLL want temporary file with >2Gb size?
  1009.     switch(whence)
  1010.     {
  1011.     case FILE_BEGIN:
  1012. wh=SEEK_SET;break;
  1013.     case FILE_END:
  1014. wh=SEEK_END;break;
  1015.     case FILE_CURRENT:
  1016. wh=SEEK_CUR;break;
  1017.     default:
  1018. return -1;
  1019.     }
  1020. #ifdef QTX
  1021.     if (val == 0 && ext != 0)
  1022. val = val&(*ext);
  1023. #endif
  1024.     return lseek(h, val, wh);
  1025. }
  1027. static HDRVR WINAPI expOpenDriverA(LPCSTR szDriverName, LPCSTR szSectionName,
  1028.    LPARAM lParam2)
  1029. {
  1030.     dbgprintf("OpenDriverA(0x%x='%s', 0x%x='%s', 0x%x) => -1n", szDriverName,  szDriverName, szSectionName, szSectionName, lParam2);
  1031.     return -1;
  1032. }
  1033. static HDRVR WINAPI expOpenDriver(LPCSTR szDriverName, LPCSTR szSectionName,
  1034.   LPARAM lParam2)
  1035. {
  1036.     dbgprintf("OpenDriver(0x%x='%s', 0x%x='%s', 0x%x) => -1n", szDriverName, szDriverName, szSectionName, szSectionName, lParam2);
  1037.     return -1;
  1038. }
  1041. static WIN_BOOL WINAPI expGetProcessAffinityMask(HANDLE hProcess,
  1042.  LPDWORD lpProcessAffinityMask,
  1043.  LPDWORD lpSystemAffinityMask)
  1044. {
  1045.     dbgprintf("GetProcessAffinityMask(0x%x, 0x%x, 0x%x) => 1n",
  1046.       hProcess, lpProcessAffinityMask, lpSystemAffinityMask);
  1047.     if(lpProcessAffinityMask)*lpProcessAffinityMask=1;
  1048.     if(lpSystemAffinityMask)*lpSystemAffinityMask=1;
  1049.     return 1;
  1050. }
  1052. static int WINAPI expMulDiv(int nNumber, int nNumerator, int nDenominator)
  1053. {
  1054.     static const long long max_int=0x7FFFFFFFLL;
  1055.     static const long long min_int=-0x80000000LL;
  1056.     long long tmp=(long long)nNumber*(long long)nNumerator;
  1057.     dbgprintf("expMulDiv %d * %d / %dn", nNumber, nNumerator, nDenominator);
  1058.     if(!nDenominator)return 1;
  1059.     tmp/=nDenominator;
  1060.     if(tmp<min_int) return 1;
  1061.     if(tmp>max_int) return 1;
  1062.     return (int)tmp;
  1063. }
  1065. static LONG WINAPI explstrcmpiA(const char* str1, const char* str2)
  1066. {
  1067.     LONG result=strcasecmp(str1, str2);
  1068.     dbgprintf("strcmpi(0x%x='%s', 0x%x='%s') => %dn", str1, str1, str2, str2, result);
  1069.     return result;
  1070. }
  1072. static LONG WINAPI explstrlenA(const char* str1)
  1073. {
  1074.     LONG result=strlen(str1);
  1075.     dbgprintf("strlen(0x%x='%.50s') => %dn", str1, str1, result);
  1076.     return result;
  1077. }
  1079. static LONG WINAPI explstrcpyA(char* str1, const char* str2)
  1080. {
  1081.     int result= (int) strcpy(str1, str2);
  1082.     dbgprintf("strcpy(0x%.50x, 0x%.50x='%.50s') => %dn", str1, str2, str2, result);
  1083.     return result;
  1084. }
  1085. static LONG WINAPI explstrcpynA(char* str1, const char* str2,int len)
  1086. {
  1087.     int result;
  1088.     if (strlen(str2)>len)
  1089. result = (int) strncpy(str1, str2,len);
  1090.     else
  1091. result = (int) strcpy(str1,str2);
  1092.     dbgprintf("strncpy(0x%x, 0x%x='%s' len %d strlen %d) => %xn", str1, str2, str2,len, strlen(str2),result);
  1093.     return result;
  1094. }
  1095. static LONG WINAPI explstrcatA(char* str1, const char* str2)
  1096. {
  1097.     int result= (int) strcat(str1, str2);
  1098.     dbgprintf("strcat(0x%x, 0x%x='%s') => %dn", str1, str2, str2, result);
  1099.     return result;
  1100. }
  1103. static LONG WINAPI expInterlockedExchange(long *dest, long l)
  1104. {
  1105.     long retval = *dest;
  1106.     *dest = l;
  1107.     return retval;
  1108. }
  1110. static void WINAPI expInitCommonControls(void)
  1111. {
  1112.     dbgprintf("InitCommonControls called!n");
  1113.     return;
  1114. }
  1116. #ifdef QTX
  1117. /* needed by QuickTime.qts */
  1118. static HWND WINAPI expCreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy,
  1119.       HWND parent, INT id, HINSTANCE inst,
  1120.               HWND buddy, INT maxVal, INT minVal, INT curVal)
  1121. {
  1122.     dbgprintf("CreateUpDownControl(...)n");
  1123.     return 0;
  1124. }
  1125. #endif
  1127. /* alex: implement this call! needed for 3ivx */
  1128. static HRESULT WINAPI expCoCreateFreeThreadedMarshaler(void *pUnkOuter, void **ppUnkInner)
  1129. {
  1130.     dbgprintf("CoCreateFreeThreadedMarshaler(%p, %p) called!n",
  1131.    pUnkOuter, ppUnkInner);
  1132. //    return 0;
  1133.     return ERROR_CALL_NOT_IMPLEMENTED;
  1134. }
  1137. static int WINAPI expDuplicateHandle(HANDLE hSourceProcessHandle,  // handle to source process
  1138.      HANDLE hSourceHandle,         // handle to duplicate
  1139.      HANDLE hTargetProcessHandle,  // handle to target process
  1140.      HANDLE* lpTargetHandle,      // duplicate handle
  1141.      DWORD dwDesiredAccess,        // requested access
  1142.      int bInheritHandle,          // handle inheritance option
  1143.      DWORD dwOptions               // optional actions
  1144.     )
  1145. {
  1146.     dbgprintf("DuplicateHandle(%p, %p, %p, %p, 0x%x, %d, %d) calledn",
  1147.       hSourceProcessHandle, hSourceHandle, hTargetProcessHandle,
  1148.       lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions);
  1149.     *lpTargetHandle = hSourceHandle;
  1150.     return 1;
  1151. }
  1153. // required by PIM1 codec (used by win98 PCTV Studio capture sw)
  1154. static HRESULT WINAPI expCoInitialize(
  1155.       LPVOID lpReserved /* [in] pointer to win32 malloc interface
  1156.       (obsolete, should be NULL) */
  1157.      )
  1158. {
  1159.     /*
  1160.      * Just delegate to the newer method.
  1161.      */
  1162.     return 0; //CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
  1163. }
  1165. static DWORD WINAPI expSetThreadAffinityMask
  1166. (
  1167.         HANDLE hThread,
  1168.         DWORD dwThreadAffinityMask
  1169. ){
  1170.     return 0;
  1171. };
  1173. /*
  1174.  * no WINAPI functions - CDECL
  1175.  */
  1176. static void* expmalloc(int size)
  1177. {
  1178.     //printf("malloc");
  1179.     //    return malloc(size);
  1180.     void* result=my_mreq(size,0);
  1181.     dbgprintf("malloc(0x%x) => 0x%xn", size,result);
  1182.     if(result==0)
  1183. printf("WARNING: malloc() failedn");
  1184.     return result;
  1185. }
  1186. static void expfree(void* mem)
  1187. {
  1188.     //    return free(mem);
  1189.     dbgprintf("free(%p)n", mem);
  1190.     my_release(mem);
  1191. }
  1192. /* needed by atrac3.acm */
  1193. static void *expcalloc(int num, int size)
  1194. {
  1195.     void* result=my_mreq(num*size,1);
  1196.     dbgprintf("calloc(%d,%d) => %pn", num,size,result);
  1197.     if(result==0)
  1198. printf("WARNING: calloc() failedn");
  1199.     return result;
  1200. }
  1201. static void* expnew(int size)
  1202. {
  1203.     //    printf("NEW:: Call from address %08xn STACK DUMP:n", *(-1+(int*)&size));
  1204.     //    printf("%08x %08x %08x %08xn",
  1205.     //    size, *(1+(int*)&size),
  1206.     //    *(2+(int*)&size),*(3+(int*)&size));
  1207.     void* result;
  1208.     assert(size >= 0);
  1210.     result=my_mreq(size,0);
  1211.     dbgprintf("new(%d) => %pn", size, result);
  1212.     if (result==0)
  1213. printf("WARNING: new() failedn");
  1214.     return result;
  1216. }
  1217. static int expdelete(void* memory)
  1218. {
  1219.     dbgprintf("delete(%p)n", memory);
  1220.     my_release(memory);
  1221.     return 0;
  1222. }
  1224. /*
  1225.  * local definition - we need only the last two members at this point
  1226.  * otherwice we would have to introduce here GUIDs and some more types..
  1227.  */
  1228. typedef struct __attribute__((__packed__))
  1229. {
  1230.     char hay[0x3C];
  1231.     void* pbUnknown; //0x3C
  1232.     unsigned long cbFormat; //0x40
  1233.     char* pbFormat; //0x44
  1234. } MY_MEDIA_TYPE;
  1235. static HRESULT WINAPI expMoCopyMediaType(MY_MEDIA_TYPE* dest, const MY_MEDIA_TYPE* src)
  1236. {
  1237.     if (!dest || !src)
  1238. return E_POINTER;
  1239.     memcpy(dest, src, sizeof(MY_MEDIA_TYPE));
  1240.     if (dest->cbFormat)
  1241.     {
  1242. dest->pbFormat = (char*) my_mreq(dest->cbFormat, 0);
  1243. if (!dest->pbFormat)
  1244.             return E_OUTOFMEMORY;
  1245. memcpy(dest->pbFormat, src->pbFormat, dest->cbFormat);
  1246.     }
  1247.     return S_OK;
  1248. }
  1249. static HRESULT WINAPI expMoInitMediaType(MY_MEDIA_TYPE* dest, DWORD cbFormat)
  1250. {
  1251.     if (!dest)
  1252.         return E_POINTER;
  1254.     dest->pbUnknown = NULL;
  1255.     dest->cbFormat = cbFormat;
  1256.     if (cbFormat)
  1257.     {
  1258. dest->pbFormat = (char*) my_mreq(cbFormat, 0);
  1259. if (!dest->pbFormat)
  1260.             return E_OUTOFMEMORY;
  1261.     }
  1262.     else 
  1263.     {
  1264.     dest->pbFormat=NULL;
  1265.     }
  1266.     return S_OK;
  1267. }
  1268. static HRESULT WINAPI expMoCreateMediaType(MY_MEDIA_TYPE** dest, DWORD cbFormat)
  1269. {
  1270.     if (!dest)
  1271. return E_POINTER;
  1272.     *dest = my_mreq(sizeof(MY_MEDIA_TYPE), 0);
  1273.     return expMoInitMediaType(*dest, cbFormat);
  1274. }
  1275. static HRESULT WINAPI expMoDuplicateMediaType(MY_MEDIA_TYPE** dest, const void* src)
  1276. {
  1277.     if (!dest)
  1278. return E_POINTER;
  1279.     *dest = my_mreq(sizeof(MY_MEDIA_TYPE), 0);
  1280.     return expMoCopyMediaType(*dest, src);
  1281. }
  1282. static HRESULT WINAPI expMoFreeMediaType(MY_MEDIA_TYPE* dest)
  1283. {
  1284.     if (!dest)
  1285. return E_POINTER;
  1286.     if (dest->pbFormat)
  1287.     {
  1288. my_release(dest->pbFormat);
  1289. dest->pbFormat = 0;
  1290.         dest->cbFormat = 0;
  1291.     }
  1292.     return S_OK;
  1293. }
  1294. static HRESULT WINAPI expMoDeleteMediaType(MY_MEDIA_TYPE* dest)
  1295. {
  1296.     if (!dest)
  1297. return E_POINTER;
  1298.     expMoFreeMediaType(dest);
  1299.     my_release(dest);
  1300.     return S_OK;
  1301. }
  1303. static int exp_snprintf( char *str, int size, const char *format, ... )
  1304. {
  1305.       int x;
  1306.       va_list va;
  1307.       va_start(va, format);
  1308.       x=snprintf(str,size,format,va);
  1309.       dbgprintf("_snprintf( 0x%x, %d, %s, ... ) => %dn",str,size,format,x);
  1310.       va_end(va);
  1311.       return x;
  1312. }
  1314. #if 0
  1315. static int exp_initterm(int v1, int v2)
  1316. {
  1317.     dbgprintf("_initterm(0x%x, 0x%x) => 0n", v1, v2);
  1318.     return 0;
  1319. }
  1320. #else
  1321. /* merged from wine - 2002.04.21 */
  1322. typedef void (*_INITTERMFUNC)();
  1323. static int exp_initterm(_INITTERMFUNC *start, _INITTERMFUNC *end)
  1324. {
  1325.     dbgprintf("_initterm(0x%x, 0x%x) %pn", start, end, *start);
  1326.     while (start < end)
  1327.     {
  1328. if (*start)
  1329. {
  1330.     //printf("call _initfunc: from: %p %dn", *start);
  1331.     // ok this trick with push/pop is necessary as otherwice
  1332.     // edi/esi registers are being trashed
  1333.     void* p = *start;
  1334.     __asm__ __volatile__
  1335. (
  1336.  "pushl %%ebx nt"
  1337.  "pushl %%ecx nt"
  1338.  "pushl %%edx nt"
  1339.  "pushl %%edi nt"
  1340.  "pushl %%esi nt"
  1341.  "call  *%%eax nt"
  1342.  "popl  %%esi nt"
  1343.  "popl  %%edi nt"
  1344.  "popl  %%edx nt"
  1345.  "popl  %%ecx nt"
  1346.  "popl  %%ebx nt"
  1347.  :
  1348.  : "a"(p)
  1349.  : "memory"
  1350. );
  1351.             //printf("done  %p  %d:%dn", end);
  1352. }
  1353. start++;
  1354.     }
  1355.     return 0;
  1356. }
  1357. #endif
  1359. static void* exp__dllonexit()
  1360. {
  1361.     // FIXME extract from WINE
  1362.     return NULL;
  1363. }
  1365. static int expwsprintfA(char* string, const char* format, ...)
  1366. {
  1367.     va_list va;
  1368.     int result;
  1369.     va_start(va, format);
  1370.     result = vsprintf(string, format, va);
  1371.     dbgprintf("wsprintfA(0x%x, '%s', ...) => %dn", string, format, result);
  1372.     va_end(va);
  1373.     return result;
  1374. }
  1376. static int expsprintf(char* str, const char* format, ...)
  1377. {
  1378.     va_list args;
  1379.     int r;
  1380.     dbgprintf("sprintf(0x%x, %s)n", str, format);
  1381.     va_start(args, format);
  1382.     r = vsprintf(str, format, args);
  1383.     va_end(args);
  1384.     return r;
  1385. }
  1386. static int expsscanf(const char* str, const char* format, ...)
  1387. {
  1388.     va_list args;
  1389.     int r;
  1390.     dbgprintf("sscanf(%s, %s)n", str, format);
  1391.     va_start(args, format);
  1392.     r = vsscanf(str, format, args);
  1393.     va_end(args);
  1394.     return r;
  1395. }
  1396. static void* expfopen(const char* path, const char* mode)
  1397. {
  1398.     printf("fopen: "%s"  mode:%sn", path, mode);
  1399.     //return fopen(path, mode);
  1400.     return fdopen(0, mode); // everything on screen
  1401. }
  1402. static int expfprintf(void* stream, const char* format, ...)
  1403. {
  1404.     va_list args;
  1405.     int r = 0;
  1406.     dbgprintf("fprintf(%p, %s, ...)n", stream, format);
  1407. #if 1
  1408.     va_start(args, format);
  1409.     r = vfprintf((FILE*) stream, format, args);
  1410.     va_end(args);
  1411. #endif
  1412.     return r;
  1413. }
  1415. static int expprintf(const char* format, ...)
  1416. {
  1417.     va_list args;
  1418.     int r;
  1419.     dbgprintf("printf(%s, ...)n", format);
  1420.     va_start(args, format);
  1421.     r = vprintf(format, args);
  1422.     va_end(args);
  1423.     return r;
  1424. }
  1426. static char* expgetenv(const char* varname)
  1427. {
  1428.     char* v = getenv(varname);
  1429.     dbgprintf("getenv(%s) => %sn", varname, v);
  1430.     return v;
  1431. }
  1433. static void* expwcscpy(WCHAR* dst, const WCHAR* src)
  1434. {
  1435.     WCHAR* p = dst;
  1436.     while ((*p++ = *src++))
  1437. ;
  1438.     return dst;
  1439. }
  1441. static char* expstrrchr(char* string, int value)
  1442. {
  1443.     char* result=strrchr(string, value);
  1444.     if(result)
  1445. dbgprintf("strrchr(0x%x='%s', %d) => 0x%x='%s'", string, string, value, result, result);
  1446.     else
  1447. dbgprintf("strrchr(0x%x='%s', %d) => 0", string, string, value);
  1448.     return result;
  1449. }
  1451. static char* expstrchr(char* string, int value)
  1452. {
  1453.     char* result=strchr(string, value);
  1454.     if(result)
  1455. dbgprintf("strchr(0x%x='%s', %d) => 0x%x='%s'", string, string, value, result, result);
  1456.     else
  1457. dbgprintf("strchr(0x%x='%s', %d) => 0", string, string, value);
  1458.     return result;
  1459. }
  1460. static int expstrlen(char* str)
  1461. {
  1462.     int result=strlen(str);
  1463.     dbgprintf("strlen(0x%x='%s') => %dn", str, str, result);
  1464.     return result;
  1465. }
  1466. static char* expstrcpy(char* str1, const char* str2)
  1467. {
  1468.     char* result= strcpy(str1, str2);
  1469.     dbgprintf("strcpy(0x%x, 0x%x='%s') => %pn", str1, str2, str2, result);
  1470.     return result;
  1471. }
  1472. static char* expstrncpy(char* str1, const char* str2, size_t count)
  1473. {
  1474.     char* result= strncpy(str1, str2, count);
  1475.     dbgprintf("strncpy(0x%x, 0x%x='%s', %d) => %pn", str1, str2, str2, count, result);
  1476.     return result;
  1477. }
  1478. static int expstrcmp(const char* str1, const char* str2)
  1479. {
  1480.     int result=strcmp(str1, str2);
  1481.     dbgprintf("strcmp(0x%x='%s', 0x%x='%s') => %dn", str1, str1, str2, str2, result);
  1482.     return result;
  1483. }
  1484. static int expstrncmp(const char* str1, const char* str2,int x)
  1485. {
  1486.     int result=strncmp(str1, str2,x);
  1487.     dbgprintf("strcmp(0x%x='%s', 0x%x='%s') => %dn", str1, str1, str2, str2, result);
  1488.     return result;
  1489. }
  1490. static char* expstrcat(char* str1, const char* str2)
  1491. {
  1492.     char* result = strcat(str1, str2);
  1493.     dbgprintf("strcat(0x%x='%s', 0x%x='%s') => %pn", str1, str1, str2, str2, result);
  1494.     return result;
  1495. }
  1496. static char* exp_strdup(const char* str1)
  1497. {
  1498.     int l = strlen(str1);
  1499.     char* result = (char*) my_mreq(l + 1,0);
  1500.     if (result)
  1501. strcpy(result, str1);
  1502.     dbgprintf("_strdup(0x%x='%s') => %pn", str1, str1, result);
  1503.     return result;
  1504. }
  1505. static int expisalnum(int c)
  1506. {
  1507.     int result= (int) isalnum(c);
  1508.     dbgprintf("isalnum(0x%x='%c' => %dn", c, c, result);
  1509.     return result;
  1510. }
  1511. static int expisspace(int c)
  1512. {
  1513.     int result= (int) isspace(c);
  1514.     dbgprintf("isspace(0x%x='%c' => %dn", c, c, result);
  1515.     return result;
  1516. }
  1517. static int expisalpha(int c)
  1518. {
  1519.     int result= (int) isalpha(c);
  1520.     dbgprintf("isalpha(0x%x='%c' => %dn", c, c, result);
  1521.     return result;
  1522. }
  1523. static int expisdigit(int c)
  1524. {
  1525.     int result= (int) isdigit(c);
  1526.     dbgprintf("isdigit(0x%x='%c' => %dn", c, c, result);
  1527.     return result;
  1528. }
  1529. static void* expmemmove(void* dest, void* src, int n)
  1530. {
  1531.     void* result = memmove(dest, src, n);
  1532.     dbgprintf("memmove(0x%x, 0x%x, %d) => %pn", dest, src, n, result);
  1533.     return result;
  1534. }
  1535. static int expmemcmp(void* dest, void* src, int n)
  1536. {
  1537.     int result = memcmp(dest, src, n);
  1538.     dbgprintf("memcmp(0x%x, 0x%x, %d) => %dn", dest, src, n, result);
  1539.     return result;
  1540. }
  1541. static void* expmemcpy(void* dest, void* src, int n)
  1542. {
  1543.     void *result = memcpy(dest, src, n);
  1544.     dbgprintf("memcpy(0x%x, 0x%x, %d) => %pn", dest, src, n, result);
  1545.     return result;
  1546. }
  1547. static void* expmemset(void* dest, int c, size_t n)
  1548. {
  1549.     void *result = memset(dest, c, n);
  1550.     dbgprintf("memset(0x%x, %d, %d) => %pn", dest, c, n, result);
  1551.     return result;
  1552. }
  1553. static time_t exptime(time_t* t)
  1554. {
  1555.     time_t result = time(t);
  1556.     dbgprintf("time(0x%x) => %dn", t, result);
  1557.     return result;
  1558. }
  1560. static int exprand(void)
  1561. {
  1562.     return rand();
  1563. }
  1565. static void expsrand(int seed)
  1566. {
  1567.     srand(seed);
  1568. }
  1570. #if 1
  1572. // preferred compilation with  -O2 -ffast-math !
  1574. static double explog10(double x)
  1575. {
  1576.     /*printf("Log10 %f => %f    0x%Lxn", x, log10(x), *((int64_t*)&x));*/
  1577.     return log10(x);
  1578. }
  1580. static double expcos(double x)
  1581. {
  1582.     /*printf("Cos %f => %f  0x%Lxn", x, cos(x), *((int64_t*)&x));*/
  1583.     return cos(x);
  1584. }
  1586. /* doens't work */
  1587. static long exp_ftol_wrong(double x)
  1588. {
  1589.     return (long) x;
  1590. }
  1592. #else
  1594. static void explog10(void)
  1595. {
  1596.     __asm__ __volatile__
  1597. (
  1598.  "fldl 8(%esp) nt"
  1599.  "fldln2 nt"
  1600.  "fxch %st(1) nt"
  1601.  "fyl2x nt"
  1602. );
  1603. }
  1605. static void expcos(void)
  1606. {
  1607.     __asm__ __volatile__
  1608. (
  1609.  "fldl 8(%esp) nt"
  1610.  "fcos nt"
  1611. );
  1612. }
  1614. #endif
  1616. // this seem to be the only how to make this function working properly
  1617. // ok - I've spent tremendous amount of time (many many many hours
  1618. // of debuging fixing & testing - it's almost unimaginable - kabi
  1620. // _ftol - operated on the float value which is already on the FPU stack
  1622. static void exp_ftol(void)
  1623. {
  1624.     __asm__ __volatile__
  1625. (
  1626.  "sub $12, %esp nt"
  1627.  "fstcw   -2(%ebp) nt"
  1628.  "wait nt"
  1629.  "movw   -2(%ebp), %ax nt"
  1630.  "orb  $0x0C, %ah nt"
  1631.  "movw    %ax, -4(%ebp) nt"
  1632.  "fldcw   -4(%ebp) nt"
  1633.  "fistpl -12(%ebp) nt"
  1634.  "fldcw   -2(%ebp) nt"
  1635.  "movl  -12(%ebp), %eax nt"
  1636.  //Note: gcc 3.03 does not do the following op if it
  1637.  //      knows that ebp=esp
  1638.  "movl %ebp, %esp       nt"
  1639. );
  1640. }
  1642. #define FPU_DOUBLES(var1,var2) double var1,var2; 
  1643.   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); 
  1644.   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
  1646. static double exp_CIpow(void)
  1647. {
  1648.     FPU_DOUBLES(x,y);
  1650.     dbgprintf("_CIpow(%lf, %lf)n", x, y);
  1651.     return pow(x, y);
  1652. }
  1654. static double exppow(double x, double y)
  1655. {
  1656.     /*printf("Pow %f  %f    0x%Lx  0x%Lx  => %fn", x, y, *((int64_t*)&x), *((int64_t*)&y), pow(x, y));*/
  1657.     return pow(x, y);
  1658. }
  1660. static double expldexp(double x, int expo)
  1661. {
  1662.     /*printf("Cos %f => %f  0x%Lxn", x, cos(x), *((int64_t*)&x));*/
  1663.     return ldexp(x, expo);
  1664. }
  1666. static double expfrexp(double x, int* expo)
  1667. {
  1668.     /*printf("Cos %f => %f  0x%Lxn", x, cos(x), *((int64_t*)&x));*/
  1669.     return frexp(x, expo);
  1670. }
  1674. static int exp_stricmp(const char* s1, const char* s2)
  1675. {
  1676.     return strcasecmp(s1, s2);
  1677. }
  1679. /* from declaration taken from Wine sources - this fountion seems to be
  1680.  * undocumented in any M$ doc */
  1681. static int exp_setjmp3(void* jmpbuf, int x)
  1682. {
  1683.     //dbgprintf("!!!!UNIMPLEMENTED: setjmp3(%p, %d) => 0n", jmpbuf, x);
  1684.     //return 0;
  1685.     __asm__ __volatile__
  1686. (
  1687.  //"mov 4(%%esp), %%edx nt"
  1688.  "mov (%%esp), %%eax   nt"
  1689.  "mov %%eax, (%%edx) nt" // store ebp
  1691.  //"mov %%ebp, (%%edx) nt"
  1692.  "mov %%ebx, 4(%%edx) nt"
  1693.  "mov %%edi, 8(%%edx) nt"
  1694.  "mov %%esi, 12(%%edx) nt"
  1695.  "mov %%esp, 16(%%edx) nt"
  1697.  "mov 4(%%esp), %%eax nt"
  1698.  "mov %%eax, 20(%%edx) nt"
  1700.  "movl $0x56433230, 32(%%edx) nt" // VC20 ??
  1701.  "movl $0, 36(%%edx) nt"
  1702.  : // output
  1703.  : "d"(jmpbuf) // input
  1704.  : "eax"
  1705. );
  1706. #if 1
  1707.     __asm__ __volatile__
  1708. (
  1709.  "mov %%fs:0, %%eax nt" // unsure
  1710.  "mov %%eax, 24(%%edx) nt"
  1711.  "cmp $0xffffffff, %%eax nt"
  1712.  "jnz l1                nt"
  1713.  "mov %%eax, 28(%%edx) nt"
  1714.  "l1:                   nt"
  1715.  :
  1716.  :
  1717.  : "eax"
  1718. );
  1719. #endif
  1721. return 0;
  1722. }
  1724. static DWORD WINAPI expGetCurrentProcessId(void)
  1725. {
  1726.     dbgprintf("GetCurrentProcessId(void) => %dn", getpid());
  1727.     return getpid(); //(DWORD)NtCurrentTeb()->pid;
  1728. }
  1731. typedef struct {
  1732.     UINT wPeriodMin;
  1733.     UINT wPeriodMax;
  1734. } TIMECAPS, *LPTIMECAPS;
  1736. static MMRESULT WINAPI exptimeGetDevCaps(LPTIMECAPS lpCaps, UINT wSize)
  1737. {
  1738.     dbgprintf("timeGetDevCaps(%p, %u) !n", lpCaps, wSize);
  1740.     lpCaps->wPeriodMin = 1;
  1741.     lpCaps->wPeriodMax = 65535;
  1742.     return 0;
  1743. }
  1745. static MMRESULT WINAPI exptimeBeginPeriod(UINT wPeriod)
  1746. {
  1747.     dbgprintf("timeBeginPeriod(%u) !n", wPeriod);
  1749.     if (wPeriod < 1 || wPeriod > 65535) return 96+1; //TIMERR_NOCANDO;
  1750.     return 0;
  1751. }
  1753. #ifdef QTX
  1754. static MMRESULT WINAPI exptimeEndPeriod(UINT wPeriod)
  1755. {
  1756.     dbgprintf("timeEndPeriod(%u) !n", wPeriod);
  1758.     if (wPeriod < 1 || wPeriod > 65535) return 96+1; //TIMERR_NOCANDO;
  1759.     return 0;
  1760. }
  1761. #endif
  1763. static void WINAPI expGlobalMemoryStatus(
  1764.             LPMEMORYSTATUS lpmem
  1765. ) {
  1766.     static MEMORYSTATUS cached_memstatus;
  1767.     static int cache_lastchecked = 0;
  1768.     SYSTEM_INFO si;
  1769.     FILE *f;
  1771.     if (time(NULL)==cache_lastchecked) {
  1772. memcpy(lpmem,&cached_memstatus,sizeof(MEMORYSTATUS));
  1773. return;
  1774.     }
  1776. #if 1
  1777.     f = fopen( "/proc/meminfo", "r" );
  1778.     if (f)
  1779.     {
  1780.         char buffer[256];
  1781.         int total, used, free, shared, buffers, cached;
  1783.         lpmem->dwLength = sizeof(MEMORYSTATUS);
  1784.         lpmem->dwTotalPhys = lpmem->dwAvailPhys = 0;
  1785.         lpmem->dwTotalPageFile = lpmem->dwAvailPageFile = 0;
  1786.         while (fgets( buffer, sizeof(buffer), f ))
  1787.         {
  1788.     /* old style /proc/meminfo ... */
  1789.             if (sscanf( buffer, "Mem: %d %d %d %d %d %d", &total, &used, &free, &shared, &buffers, &cached ))
  1790.             {
  1791.                 lpmem->dwTotalPhys += total;
  1792.                 lpmem->dwAvailPhys += free + buffers + cached;
  1793.             }
  1794.             if (sscanf( buffer, "Swap: %d %d %d", &total, &used, &free ))
  1795.             {
  1796.                 lpmem->dwTotalPageFile += total;
  1797.                 lpmem->dwAvailPageFile += free;
  1798.             }
  1800.     /* new style /proc/meminfo ... */
  1801.     if (sscanf(buffer, "MemTotal: %d", &total))
  1802.      lpmem->dwTotalPhys = total*1024;
  1803.     if (sscanf(buffer, "MemFree: %d", &free))
  1804.      lpmem->dwAvailPhys = free*1024;
  1805.     if (sscanf(buffer, "SwapTotal: %d", &total))
  1806.         lpmem->dwTotalPageFile = total*1024;
  1807.     if (sscanf(buffer, "SwapFree: %d", &free))
  1808.         lpmem->dwAvailPageFile = free*1024;
  1809.     if (sscanf(buffer, "Buffers: %d", &buffers))
  1810.         lpmem->dwAvailPhys += buffers*1024;
  1811.     if (sscanf(buffer, "Cached: %d", &cached))
  1812.         lpmem->dwAvailPhys += cached*1024;
  1813.         }
  1814.         fclose( f );
  1816.         if (lpmem->dwTotalPhys)
  1817.         {
  1818.             DWORD TotalPhysical = lpmem->dwTotalPhys+lpmem->dwTotalPageFile;
  1819.             DWORD AvailPhysical = lpmem->dwAvailPhys+lpmem->dwAvailPageFile;
  1820.             lpmem->dwMemoryLoad = (TotalPhysical-AvailPhysical)
  1821.                                       / (TotalPhysical / 100);
  1822.         }
  1823.     } else
  1824. #endif
  1825.     {
  1826. /* FIXME: should do something for other systems */
  1827. lpmem->dwMemoryLoad    = 0;
  1828. lpmem->dwTotalPhys     = 16*1024*1024;
  1829. lpmem->dwAvailPhys     = 16*1024*1024;
  1830. lpmem->dwTotalPageFile = 16*1024*1024;
  1831. lpmem->dwAvailPageFile = 16*1024*1024;
  1832.     }
  1833.     expGetSystemInfo(&si);
  1834.     lpmem->dwTotalVirtual  = si.lpMaximumApplicationAddress-si.lpMinimumApplicationAddress;
  1835.     /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
  1836.     lpmem->dwAvailVirtual  = lpmem->dwTotalVirtual-64*1024;
  1837.     memcpy(&cached_memstatus,lpmem,sizeof(MEMORYSTATUS));
  1838.     cache_lastchecked = time(NULL);
  1840.     /* it appears some memory display programs want to divide by these values */
  1841.     if(lpmem->dwTotalPageFile==0)
  1842.         lpmem->dwTotalPageFile++;
  1844.     if(lpmem->dwAvailPageFile==0)
  1845.         lpmem->dwAvailPageFile++;
  1846. }
  1848. /**********************************************************************
  1849.  * SetThreadPriority [KERNEL32.@]  Sets priority for thread.
  1850.  *
  1851.  * RETURNS
  1852.  *    Success: TRUE
  1853.  *    Failure: FALSE
  1854.  */
  1855. static WIN_BOOL WINAPI expSetThreadPriority(
  1856.     HANDLE hthread, /* [in] Handle to thread */
  1857.     INT priority)   /* [in] Thread priority level */
  1858. {
  1859.     dbgprintf("SetThreadPriority(%p,%d)n",hthread,priority);
  1860.     return TRUE;
  1861. }
  1863. static void WINAPI expExitProcess( DWORD status )
  1864. {
  1865.     printf("EXIT - code %ldn",status);
  1866.     exit(status);
  1867. }
  1869. static INT WINAPI expMessageBoxA(HWND hWnd, LPCSTR text, LPCSTR title, UINT type){
  1870.     printf("MSGBOX '%s' '%s' (%d)n",text,title,type);
  1871. #ifdef QTX
  1872.     if (type == MB_ICONHAND && !strlen(text) && !strlen(title))
  1873. return IDIGNORE;
  1874. #endif
  1875.     return IDOK;
  1876. }
  1878. /* these are needed for mss1 */
  1880. /* defined in stubs.s */
  1881. void exp_EH_prolog(void);
  1883. #include <netinet/in.h>
  1884. static WINAPI inline unsigned long int exphtonl(unsigned long int hostlong)
  1885. {
  1886. //    dbgprintf("htonl(%x) => %xn", hostlong, htonl(hostlong));
  1887.     return htonl(hostlong);
  1888. }
  1890. static WINAPI inline unsigned long int expntohl(unsigned long int netlong)
  1891. {
  1892. //    dbgprintf("ntohl(%x) => %xn", netlong, ntohl(netlong));
  1893.     return ntohl(netlong);
  1894. }
  1895. static void WINAPI expVariantInit(void* p)
  1896. {
  1897.     printf("InitCommonControls called!n");
  1898.     return;
  1899. }
  1901. static int WINAPI expRegisterClassA(const void/*WNDCLASSA*/ *wc)
  1902. {
  1903.     dbgprintf("RegisterClassA(%p) => random idn", wc);
  1904.     return time(NULL); /* be precise ! */
  1905. }
  1907. static int WINAPI expUnregisterClassA(const char *className, HINSTANCE hInstance)
  1908. {
  1909.     dbgprintf("UnregisterClassA(%s, %p) => 0n", className, hInstance);
  1910.     return 0;
  1911. }
  1913. #ifdef QTX
  1914. /* should be fixed bcs it's not fully strlen equivalent */
  1915. static int expSysStringByteLen(void *str)
  1916. {
  1917.     dbgprintf("SysStringByteLen(%p) => %dn", str, strlen(str));
  1918.     return strlen(str);
  1919. }
  1921. static int expDirectDrawCreate(void)
  1922. {
  1923.     dbgprintf("DirectDrawCreate(...) => NULLn");
  1924.     return 0;
  1925. }
  1927. #if 1
  1928. typedef struct tagPALETTEENTRY { 
  1929.     BYTE peRed; 
  1930.     BYTE peGreen; 
  1931.     BYTE peBlue; 
  1932.     BYTE peFlags; 
  1933. } PALETTEENTRY; 
  1935. /* reversed the first 2 entries */
  1936. typedef struct tagLOGPALETTE { 
  1937.     WORD         palNumEntries; 
  1938.     WORD         palVersion; 
  1939.     PALETTEENTRY palPalEntry[1]; 
  1940. } LOGPALETTE; 
  1942. static HPALETTE WINAPI expCreatePalette(CONST LOGPALETTE *lpgpl)
  1943. {
  1944.     HPALETTE test;
  1945.     int i;
  1946.     
  1947.     dbgprintf("CreatePalette(%x) => NULLn", lpgpl);
  1949.     i = sizeof(LOGPALETTE)+((lpgpl->palNumEntries-1)*sizeof(PALETTEENTRY));
  1950.     test = (HPALETTE)malloc(i);
  1951.     memcpy((void *)test, lpgpl, i);
  1953.     return test;
  1954. }
  1955. #else
  1956. static int expCreatePalette(void)
  1957. {
  1958.     dbgprintf("CreatePalette(...) => NULLn");
  1959.     return NULL;
  1960. }
  1961. #endif
  1963. static int WINAPI expGetClientRect(HWND win, RECT *r)
  1964. {
  1965.     dbgprintf("GetClientRect(0x%x, 0x%x) => 1n", win, r);
  1966.     r->right = PSEUDO_SCREEN_WIDTH;
  1967.     r->left = 0;
  1968.     r->bottom = PSEUDO_SCREEN_HEIGHT;
  1969.     r->top = 0;
  1970.     return 1;
  1971. }
  1973. #if 0
  1974. typedef struct tagPOINT { 
  1975.     LONG x; 
  1976.     LONG y; 
  1977. } POINT, *PPOINT; 
  1978. #endif
  1980. static int WINAPI expClientToScreen(HWND win, POINT *p)
  1981. {
  1982.     dbgprintf("ClientToScreen(0x%x, 0x%x = %d,%d) => 1n", win, p, p->x, p->y);
  1983.     p->x = 0;
  1984.     p->y = 0;
  1985.     return 1;
  1986. }
  1987. #endif
  1989. /* for m3jpeg */
  1990. static int WINAPI expSetThreadIdealProcessor(HANDLE thread, int proc)
  1991. {
  1992.     dbgprintf("SetThreadIdealProcessor(0x%x, %x) => 0n", thread, proc);
  1993.     return 0;
  1994. }
  1996. static int WINAPI expMessageBeep(int type)
  1997. {
  1998.     dbgprintf("MessageBeep(%d) => 1n", type);
  1999.     return 1;
  2000. }
  2002. static int WINAPI expDialogBoxParamA(void *inst, const char *name,
  2003.     HWND parent, void *dialog_func, void *init_param)
  2004. {
  2005.     dbgprintf("DialogBoxParamA(0x%x, 0x%x = %s, 0x%x, 0x%x, 0x%x) => 0x42424242n",
  2006. inst, name, name, parent, dialog_func, init_param);
  2007.     return 0x42424242;
  2008. }
  2010. /* needed by imagepower mjpeg2k */
  2011. static void *exprealloc(void *ptr, size_t size)
  2012. {
  2013.     dbgprintf("realloc(0x%x, %x)n", ptr, size);
  2014.     if (!ptr)
  2015. return my_mreq(size,0);
  2016.     else
  2017. return my_realloc(ptr, size);        
  2018. }
  2020. /* Fake GetOpenFileNameA from comdlg32.dll for ViVD codec */
  2021. static WIN_BOOL WINAPI expGetOpenFileNameA(/*LPOPENFILENAMEA*/ void* lpfn)
  2022. {
  2023.     return 1;
  2024. }
  2026. static double expfloor(double x)
  2027. {
  2028.     dbgprintf("floor(%lf)n", x);
  2029.     return floor(x);
  2030. }
  2032. #define FPU_DOUBLE(var) double var; 
  2033.   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
  2035. static double exp_CIcos(void)
  2036. {
  2037.     FPU_DOUBLE(x);
  2039.     dbgprintf("_CIcos(%lf)n", x);
  2040.     return cos(x);
  2041. }
  2043. static double exp_CIsin(void)
  2044. {
  2045.     FPU_DOUBLE(x);
  2047.     dbgprintf("_CIsin(%lf)n", x);
  2048.     return sin(x);
  2049. }
  2051. struct exports
  2052. {
  2053.     char name[64];
  2054.     int id;
  2055.     void* func;
  2056. };
  2057. struct libs
  2058. {
  2059.     char name[64];
  2060.     int length;
  2061.     struct exports* exps;
  2062. };
  2064. #define FF(X,Y) 
  2065.     {#X, Y, (void*)exp##X},
  2067. struct exports exp_kernel32[]=
  2068. {
  2069.     FF(GetVolumeInformationA,-1)
  2070.     FF(GetDriveTypeA,-1)
  2071.     FF(GetLogicalDriveStringsA,-1)
  2072.     FF(IsBadWritePtr, 357)
  2073.     FF(IsBadReadPtr, 354)
  2074.     FF(IsBadStringPtrW, -1)
  2075.     FF(IsBadStringPtrA, -1)
  2076.     FF(DisableThreadLibraryCalls, -1)
  2077.     FF(CreateThread, -1)
  2078.     FF(CreateEventA, -1)
  2079.     FF(SetEvent, -1)
  2080.     FF(ResetEvent, -1)
  2081.     FF(WaitForSingleObject, -1)
  2082. #ifdef QTX
  2083.     FF(WaitForMultipleObjects, -1)
  2084.     FF(ExitThread, -1)
  2085.     FF(CreateMutexA,-1)
  2086.     FF(ReleaseMutex,-1)
  2087. #endif
  2088.     FF(GetSystemInfo, -1)
  2089.     FF(GetVersion, 332)
  2090.     FF(HeapCreate, 461)
  2091.     FF(HeapAlloc, -1)
  2092.     FF(HeapDestroy, -1)
  2093.     FF(HeapFree, -1)
  2094.     FF(HeapSize, -1)
  2095.     FF(HeapReAlloc,-1)
  2096.     FF(GetProcessHeap, -1)
  2097.     FF(VirtualAlloc, -1)
  2098.     FF(VirtualFree, -1)
  2099.     FF(InitializeCriticalSection, -1)
  2100.     FF(EnterCriticalSection, -1)
  2101.     FF(LeaveCriticalSection, -1)
  2102.     FF(DeleteCriticalSection, -1)
  2103.     FF(TlsAlloc, -1)
  2104.     FF(TlsFree, -1)
  2105.     FF(TlsGetValue, -1)
  2106.     FF(TlsSetValue, -1)
  2107.     FF(GetCurrentThreadId, -1)
  2108.     FF(GetCurrentProcess, -1)
  2109.     FF(LocalAlloc, -1)
  2110.     FF(LocalReAlloc,-1)
  2111.     FF(LocalLock, -1)
  2112.     FF(GlobalAlloc, -1)
  2113.     FF(GlobalReAlloc, -1)
  2114.     FF(GlobalLock, -1)
  2115.     FF(GlobalSize, -1)
  2116.     FF(MultiByteToWideChar, 427)
  2117.     FF(WideCharToMultiByte, -1)
  2118.     FF(GetVersionExA, -1)
  2119.     FF(CreateSemaphoreA, -1)
  2120.     FF(QueryPerformanceCounter, -1)
  2121.     FF(QueryPerformanceFrequency, -1)
  2122.     FF(LocalHandle, -1)
  2123.     FF(LocalUnlock, -1)
  2124.     FF(LocalFree, -1)
  2125.     FF(GlobalHandle, -1)
  2126.     FF(GlobalUnlock, -1)
  2127.     FF(GlobalFree, -1)
  2128.     FF(LoadResource, -1)
  2129.     FF(ReleaseSemaphore, -1)
  2130.     FF(FindResourceA, -1)
  2131.     FF(LockResource, -1)
  2132.     FF(FreeResource, -1)
  2133.     FF(SizeofResource, -1)
  2134.     FF(CloseHandle, -1)
  2135.     FF(GetCommandLineA, -1)
  2136.     FF(GetEnvironmentStringsW, -1)
  2137.     FF(FreeEnvironmentStringsW, -1)
  2138.     FF(FreeEnvironmentStringsA, -1)
  2139.     FF(GetEnvironmentStrings, -1)
  2140.     FF(GetStartupInfoA, -1)
  2141.     FF(GetStdHandle, -1)
  2142.     FF(GetFileType, -1)
  2143. #ifdef QTX
  2144.     FF(GetFileAttributesA, -1)
  2145. #endif
  2146.     FF(SetHandleCount, -1)
  2147.     FF(GetACP, -1)
  2148.     FF(GetModuleFileNameA, -1)
  2149.     FF(SetUnhandledExceptionFilter, -1)
  2150.     FF(LoadLibraryA, -1)
  2151.     FF(GetProcAddress, -1)
  2152.     FF(FreeLibrary, -1)
  2153.     FF(CreateFileMappingA, -1)
  2154.     FF(OpenFileMappingA, -1)
  2155.     FF(MapViewOfFile, -1)
  2156.     FF(UnmapViewOfFile, -1)
  2157.     FF(Sleep, -1)
  2158.     FF(GetModuleHandleA, -1)
  2159.     FF(GetProfileIntA, -1)
  2160.     FF(GetPrivateProfileIntA, -1)
  2161.     FF(GetPrivateProfileStringA, -1)
  2162.     FF(WritePrivateProfileStringA, -1)
  2163.     FF(GetLastError, -1)
  2164.     FF(SetLastError, -1)
  2165.     FF(InterlockedIncrement, -1)
  2166.     FF(InterlockedDecrement, -1)
  2167.     FF(GetTimeZoneInformation, -1)
  2168.     FF(OutputDebugStringA, -1)
  2169.     FF(GetLocalTime, -1)
  2170.     FF(GetSystemTime, -1)
  2171.     FF(GetSystemTimeAsFileTime, -1)
  2172.     FF(GetEnvironmentVariableA, -1)
  2173.     FF(SetEnvironmentVariableA, -1)
  2174.     FF(RtlZeroMemory,-1)
  2175.     FF(RtlMoveMemory,-1)
  2176.     FF(RtlFillMemory,-1)
  2177.     FF(GetTempPathA,-1)
  2178.     FF(FindFirstFileA,-1)
  2179.     FF(FindNextFileA,-1)
  2180.     FF(FindClose,-1)
  2181.     FF(FileTimeToLocalFileTime,-1)
  2182.     FF(DeleteFileA,-1)
  2183.     FF(ReadFile,-1)
  2184.     FF(WriteFile,-1)
  2185.     FF(SetFilePointer,-1)
  2186.     FF(GetTempFileNameA,-1)
  2187.     FF(CreateFileA,-1)
  2188.     FF(GetSystemDirectoryA,-1)
  2189.     FF(GetWindowsDirectoryA,-1)
  2190. #ifdef QTX
  2191.     FF(GetCurrentDirectoryA,-1)
  2192.     FF(SetCurrentDirectoryA,-1)
  2193.     FF(CreateDirectoryA,-1)
  2194. #endif
  2195.     FF(GetShortPathNameA,-1)
  2196.     FF(GetFullPathNameA,-1)
  2197.     FF(SetErrorMode, -1)
  2198.     FF(IsProcessorFeaturePresent, -1)
  2199.     FF(GetProcessAffinityMask, -1)
  2200.     FF(InterlockedExchange, -1)
  2201.     FF(InterlockedCompareExchange, -1)
  2202.     FF(MulDiv, -1)
  2203.     FF(lstrcmpiA, -1)
  2204.     FF(lstrlenA, -1)
  2205.     FF(lstrcpyA, -1)
  2206.     FF(lstrcatA, -1)
  2207.     FF(lstrcpynA,-1)
  2208.     FF(GetProcessVersion,-1)
  2209.     FF(GetCurrentThread,-1)
  2210.     FF(GetOEMCP,-1)
  2211.     FF(GetCPInfo,-1)
  2212.     FF(DuplicateHandle,-1)
  2213.     FF(GetTickCount, -1)
  2214.     FF(SetThreadAffinityMask,-1)
  2215.     FF(GetCurrentProcessId,-1)
  2216.     FF(GlobalMemoryStatus,-1)
  2217.     FF(SetThreadPriority,-1)
  2218.     FF(ExitProcess,-1)
  2219.     {"LoadLibraryExA", -1, (void*)&LoadLibraryExA},
  2220.     FF(SetThreadIdealProcessor,-1)
  2221. };
  2223. struct exports exp_msvcrt[]={
  2224.     FF(malloc, -1)
  2225.     FF(_initterm, -1)
  2226.     FF(__dllonexit, -1)
  2227.     FF(_snprintf,-1)
  2228.     FF(free, -1)
  2229.     {"??3@YAXPAX@Z", -1, expdelete},
  2230.     {"??2@YAPAXI@Z", -1, expnew},
  2231.     {"_adjust_fdiv", -1, (void*)&_adjust_fdiv},
  2232.     FF(strrchr, -1)
  2233.     FF(strchr, -1)
  2234.     FF(strlen, -1)
  2235.     FF(strcpy, -1)
  2236.     FF(strncpy, -1)
  2237.     FF(wcscpy, -1)
  2238.     FF(strcmp, -1)
  2239.     FF(strncmp, -1)
  2240.     FF(strcat, -1)
  2241.     FF(_stricmp,-1)
  2242.     FF(_strdup,-1)
  2243.     FF(_setjmp3,-1)
  2244.     FF(isalnum, -1)
  2245.     FF(isspace, -1)
  2246.     FF(isalpha, -1)
  2247.     FF(isdigit, -1)
  2248.     FF(memmove, -1)
  2249.     FF(memcmp, -1)
  2250.     FF(memset, -1)
  2251.     FF(memcpy, -1)
  2252.     FF(time, -1)
  2253.     FF(rand, -1)
  2254.     FF(srand, -1)
  2255.     FF(log10, -1)
  2256.     FF(pow, -1)
  2257.     FF(cos, -1)
  2258.     FF(_ftol,-1)
  2259.     FF(_CIpow,-1)
  2260.     FF(_CIcos,-1)
  2261.     FF(_CIsin,-1)
  2262.     FF(ldexp,-1)
  2263.     FF(frexp,-1)
  2264.     FF(sprintf,-1)
  2265.     FF(sscanf,-1)
  2266.     FF(fopen,-1)
  2267.     FF(fprintf,-1)
  2268.     FF(printf,-1)
  2269.     FF(getenv,-1)
  2270.     FF(floor,-1)
  2271. /* needed by frapsvid.dll */
  2272.     {"strstr",-1,(char *)&strstr},
  2273.     {"qsort",-1,(void *)&qsort},
  2274. #ifdef MPLAYER
  2275.     FF(_EH_prolog,-1)
  2276. #endif
  2277.     FF(calloc,-1)
  2278.     {"ceil",-1,(void*)&ceil},
  2279. /* needed by imagepower mjpeg2k */
  2280.     {"clock",-1,(void*)&clock},
  2281.     {"memchr",-1,(void*)&memchr},
  2282.     {"vfprintf",-1,(void*)&vfprintf},
  2283. //    {"realloc",-1,(void*)&realloc},
  2284.     FF(realloc,-1)
  2285.     {"puts",-1,(void*)&puts}
  2286. };
  2287. struct exports exp_winmm[]={
  2288.     FF(GetDriverModuleHandle, -1)
  2289.     FF(timeGetTime, -1)
  2290.     FF(DefDriverProc, -1)
  2291.     FF(OpenDriverA, -1)
  2292.     FF(OpenDriver, -1)
  2293.     FF(timeGetDevCaps, -1)
  2294.     FF(timeBeginPeriod, -1)
  2295. #ifdef QTX
  2296.     FF(timeEndPeriod, -1)
  2297.     FF(waveOutGetNumDevs, -1)
  2298. #endif
  2299. };
  2300. struct exports exp_user32[]={
  2301.     FF(LoadIconA,-1)
  2302.     FF(LoadStringA, -1)
  2303.     FF(wsprintfA, -1)
  2304.     FF(GetDC, -1)
  2305.     FF(GetDesktopWindow, -1)
  2306.     FF(ReleaseDC, -1)
  2307.     FF(IsRectEmpty, -1)
  2308.     FF(LoadCursorA,-1)
  2309.     FF(SetCursor,-1)
  2310.     FF(GetCursorPos,-1)
  2311. #ifdef QTX
  2312.     FF(ShowCursor,-1)
  2313. #endif
  2314.     FF(RegisterWindowMessageA,-1)
  2315.     FF(GetSystemMetrics,-1)
  2316.     FF(GetSysColor,-1)
  2317.     FF(GetSysColorBrush,-1)
  2318.     FF(GetWindowDC, -1)
  2319.     FF(DrawTextA, -1)
  2320.     FF(MessageBoxA, -1)
  2321.     FF(RegisterClassA, -1)
  2322.     FF(UnregisterClassA, -1)
  2323. #ifdef QTX
  2324.     FF(GetWindowRect, -1)
  2325.     FF(MonitorFromWindow, -1)
  2326.     FF(MonitorFromRect, -1)
  2327.     FF(MonitorFromPoint, -1)
  2328.     FF(EnumDisplayMonitors, -1)
  2329.     FF(GetMonitorInfoA, -1)
  2330.     FF(EnumDisplayDevicesA, -1)
  2331.     FF(GetClientRect, -1)
  2332.     FF(ClientToScreen, -1)
  2333.     FF(IsWindowVisible, -1)
  2334.     FF(GetActiveWindow, -1)
  2335.     FF(GetClassNameA, -1)
  2336.     FF(GetClassInfoA, -1)
  2337.     FF(GetWindowLongA, -1)
  2338.     FF(EnumWindows, -1)
  2339.     FF(GetWindowThreadProcessId, -1)
  2340.     FF(CreateWindowExA, -1)
  2341. #endif
  2342.     FF(MessageBeep, -1)
  2343.     FF(DialogBoxParamA, -1)
  2344. };
  2345. struct exports exp_advapi32[]={
  2346.     FF(RegCloseKey, -1)
  2347.     FF(RegCreateKeyA, -1)
  2348.     FF(RegCreateKeyExA, -1)
  2349.     FF(RegEnumKeyExA, -1)
  2350.     FF(RegEnumValueA, -1)
  2351.     FF(RegOpenKeyA, -1)
  2352.     FF(RegOpenKeyExA, -1)
  2353.     FF(RegQueryValueExA, -1)
  2354.     FF(RegSetValueExA, -1)
  2355.     FF(RegQueryInfoKeyA, -1)
  2356. };
  2357. struct exports exp_gdi32[]={
  2358.     FF(CreateCompatibleDC, -1)
  2359.     FF(CreateFontA, -1)
  2360.     FF(DeleteDC, -1)
  2361.     FF(DeleteObject, -1)
  2362.     FF(GetDeviceCaps, -1)
  2363.     FF(GetSystemPaletteEntries, -1)
  2364. #ifdef QTX
  2365.     FF(CreatePalette, -1)
  2366.     FF(GetObjectA, -1)
  2367.     FF(CreateRectRgn, -1)
  2368. #endif
  2369. };
  2370. struct exports exp_version[]={
  2371.     FF(GetFileVersionInfoSizeA, -1)
  2372. };
  2373. struct exports exp_ole32[]={
  2374.     FF(CoCreateFreeThreadedMarshaler,-1)
  2375.     FF(CoCreateInstance, -1)
  2376.     FF(CoInitialize, -1)
  2377.     FF(CoTaskMemAlloc, -1)
  2378.     FF(CoTaskMemFree, -1)
  2379.     FF(StringFromGUID2, -1)
  2380. };
  2381. // do we really need crtdll ???
  2382. // msvcrt is the correct place probably...
  2383. struct exports exp_crtdll[]={
  2384.     FF(memcpy, -1)
  2385.     FF(wcscpy, -1)
  2386. };
  2387. struct exports exp_comctl32[]={
  2388.     FF(StringFromGUID2, -1)
  2389.     FF(InitCommonControls, 17)
  2390. #ifdef QTX
  2391.     FF(CreateUpDownControl, 16)
  2392. #endif
  2393. };
  2394. struct exports exp_wsock32[]={
  2395.     FF(htonl,8)
  2396.     FF(ntohl,14)
  2397. };
  2398. struct exports exp_msdmo[]={
  2399.     FF(memcpy, -1) // just test
  2400.     FF(MoCopyMediaType, -1)
  2401.     FF(MoCreateMediaType, -1)
  2402.     FF(MoDeleteMediaType, -1)
  2403.     FF(MoDuplicateMediaType, -1)
  2404.     FF(MoFreeMediaType, -1)
  2405.     FF(MoInitMediaType, -1)
  2406. };
  2407. struct exports exp_oleaut32[]={
  2408.     FF(VariantInit, 8)
  2409. #ifdef QTX
  2410.     FF(SysStringByteLen, 149)
  2411. #endif
  2412. };
  2414. /*  realplayer8:
  2415. DLL Name: PNCRT.dll
  2416. vma:  Hint/Ord Member-Name
  2417. 22ff4   615  free
  2418. 2302e   250  _ftol
  2419. 22fea   666  malloc
  2420. 2303e   609  fprintf
  2421. 2305e   167  _adjust_fdiv
  2422. 23052   280  _initterm
  2424. 22ffc   176  _beginthreadex
  2425. 23036   284  _iob
  2426. 2300e    85  __CxxFrameHandler
  2427. 23022   411  _purecall
  2428. */
  2429. #ifdef REALPLAYER
  2430. struct exports exp_pncrt[]={
  2431.     FF(malloc, -1) // just test
  2432.     FF(free, -1) // just test
  2433.     FF(fprintf, -1) // just test
  2434.     {"_adjust_fdiv", -1, (void*)&_adjust_fdiv},
  2435.     FF(_ftol,-1)
  2436.     FF(_initterm, -1)
  2437.     {"??3@YAXPAX@Z", -1, expdelete},
  2438.     {"??2@YAPAXI@Z", -1, expnew},
  2439.     FF(__dllonexit, -1)
  2440.     FF(strncpy, -1)
  2441.     FF(_CIpow,-1)
  2442.     FF(calloc,-1)
  2443.     FF(memmove, -1)
  2444. };
  2445. #endif
  2447. #ifdef QTX
  2448. struct exports exp_ddraw[]={
  2449.     FF(DirectDrawCreate, -1)
  2450. };
  2451. #endif
  2453. struct exports exp_comdlg32[]={
  2454.     FF(GetOpenFileNameA, -1)
  2455. };
  2457. #define LL(X) 
  2458.     {#X".dll", sizeof(exp_##X)/sizeof(struct exports), exp_##X},
  2460. struct libs libraries[]={
  2461.     LL(kernel32)
  2462.     LL(msvcrt)
  2463.     LL(winmm)
  2464.     LL(user32)
  2465.     LL(advapi32)
  2466.     LL(gdi32)
  2467.     LL(version)
  2468.     LL(ole32)
  2469.     LL(oleaut32)
  2470.     LL(crtdll)
  2471.     LL(comctl32)
  2472.     LL(wsock32)
  2473.     LL(msdmo)
  2474. #ifdef REALPLAYER
  2475.     LL(pncrt)
  2476. #endif
  2477. #ifdef QTX
  2478.     LL(ddraw)
  2479. #endif
  2480.     LL(comdlg32)
  2481. };
  2483. static void ext_stubs(void)
  2484. {
  2485.     // expects:
  2486.     //  ax  position index
  2487.     //  cx  address of printf function
  2488. #if 1
  2489.     __asm__ __volatile__
  2490. (
  2491.          "push %%edx nt"
  2492.  "movl $0xdeadbeef, %%eax nt"
  2493.  "movl $0xdeadbeef, %%edx nt"
  2494.  "shl $5, %%eax nt" // ax * 32
  2495.  "addl $0xdeadbeef, %%eax nt" // overwrite export_names
  2496.  "pushl %%eax nt"
  2497.  "pushl $0xdeadbeef    nt"                   // overwrite called_unk
  2498.  "call *%%edx nt"                   // printf (via dx)
  2499.  "addl $8, %%esp nt"
  2500.  "xorl %%eax, %%eax nt"
  2501.  "pop %%edx             nt"
  2502.  :
  2503.  :
  2504.  : "eax"
  2505. );
  2506. #else
  2507.     __asm__ __volatile__
  2508. (
  2509.          "push %%edx nt"
  2510.  "movl $0, %%eax nt"
  2511.  "movl $0, %%edx nt"
  2512.  "shl $5, %%eax nt" // ax * 32
  2513.  "addl %0, %%eax nt"
  2514.  "pushl %%eax nt"
  2515.  "pushl %1 nt"
  2516.  "call *%%edx nt"                   // printf (via dx)
  2517.  "addl $8, %%esp nt"
  2518.  "xorl %%eax, %%eax nt"
  2519.  "pop %%edx nt"
  2520.  ::"m"(*export_names), "m"(*called_unk)
  2521. : "memory", "edx", "eax"
  2522. );
  2523. #endif
  2525. }
  2527. //static void add_stub(int pos)
  2529. extern int unk_exp1;
  2530. static int pos=0;
  2531. static char extcode[20000];// place for 200 unresolved exports
  2532. static const char* called_unk = "Called unk_%sn";
  2534. static void* add_stub(void)
  2535. {
  2536.     // generated code in runtime!
  2537.     char* answ = (char*)extcode+pos*0x30;
  2538. #if 0
  2539.     memcpy(answ, &unk_exp1, 0x64);
  2540.     *(int*)(answ+9)=pos;
  2541.     *(int*)(answ+47)-=((int)answ-(int)&unk_exp1);
  2542. #endif
  2543.     memcpy(answ, ext_stubs, 0x2f); // 0x2c is current size
  2544.     //answ[4] = 0xb8; // movl $0, eax  (0xb8 0x00000000)
  2545.     *((int*) (answ + 5)) = pos;
  2546.     //answ[9] = 0xba; // movl $0, edx  (0xba 0x00000000)
  2547.     *((long*) (answ + 10)) = (long)printf;
  2548.     //answ[17] = 0x05; // addl $0, eax  (0x05 0x00000000)
  2549.     *((long*) (answ + 18)) = (long)export_names;
  2550.     //answ[23] = 0x68; // pushl $0  (0x68 0x00000000)
  2551.     *((long*) (answ + 24)) = (long)called_unk;
  2552.     pos++;
  2553.     return (void*)answ;
  2554. }
  2556. void* LookupExternal(const char* library, int ordinal)
  2557. {
  2558.     int i,j;
  2559.     if(library==0)
  2560.     {
  2561. printf("ERROR: library=0n");
  2562. return (void*)ext_unknown;
  2563.     }
  2564.     //    printf("%x %xn", &unk_exp1, &unk_exp2);
  2566.     dbgprintf("External func %s:%dn", library, ordinal);
  2568.     for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++)
  2569.     {
  2570. if(strcasecmp(library, libraries[i].name))
  2571.     continue;
  2572. for(j=0; j<libraries[i].length; j++)
  2573. {
  2574.     if(ordinal!=libraries[i].exps[j].id)
  2575. continue;
  2576.     //printf("Hit: 0x%pn", libraries[i].exps[j].func);
  2577.     return libraries[i].exps[j].func;
  2578. }
  2579.     }
  2581. #ifndef LOADLIB_TRY_NATIVE
  2582.   /* hack for truespeech and vssh264*/
  2583.   if (!strcmp(library, "tsd32.dll") || !strcmp(library,"vssh264dec.dll") || !strcmp(library,"LCMW2.dll") || !strcmp(library,"VDODEC32.dll"))
  2584. #endif
  2585.     /* ok, this is a hack, and a big memory leak. should be fixed. - alex */
  2586.     {
  2587. int hand;
  2588. WINE_MODREF *wm;
  2589. void *func;
  2591. hand = LoadLibraryA(library);
  2592. if (!hand)
  2593.     goto no_dll;
  2594. wm = MODULE32_LookupHMODULE(hand);
  2595. if (!wm)
  2596. {
  2597.     FreeLibrary(hand);
  2598.     goto no_dll;
  2599. }
  2600. func = PE_FindExportedFunction(wm, (LPCSTR) ordinal, 0);
  2601. if (!func)
  2602. {
  2603.     printf("No such ordinal in external dlln");
  2604.     FreeLibrary((int)hand);
  2605.     goto no_dll;
  2606. }
  2608. printf("External dll loaded (offset: 0x%x, func: %p)n",
  2609.        hand, func);
  2610. return func;
  2611.     }
  2613. no_dll:
  2614.     if(pos>150)return 0;
  2615.     sprintf(export_names[pos], "%s:%d", library, ordinal);
  2616.     return add_stub();
  2617. }
  2619. void* LookupExternalByName(const char* library, const char* name)
  2620. {
  2621.     char* answ;
  2622.     int i,j;
  2623.     //   return (void*)ext_unknown;
  2624.     if(library==0)
  2625.     {
  2626. printf("ERROR: library=0n");
  2627. return (void*)ext_unknown;
  2628.     }
  2629.     if(name==0)
  2630.     {
  2631. printf("ERROR: name=0n");
  2632. return (void*)ext_unknown;
  2633.     }
  2634.     dbgprintf("External func %s:%sn", library, name);
  2635.     for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++)
  2636.     {
  2637. if(strcasecmp(library, libraries[i].name))
  2638.     continue;
  2639. for(j=0; j<libraries[i].length; j++)
  2640. {
  2641.     if(strcmp(name, libraries[i].exps[j].name))
  2642. continue;
  2643.     //     printf("Hit: 0x%08Xn", libraries[i].exps[j].func);
  2644.     return libraries[i].exps[j].func;
  2645. }
  2646.     }
  2648. #ifndef LOADLIB_TRY_NATIVE
  2649.   /* hack for vss h264 */
  2650.   if (!strcmp(library,"vssh264core.dll"))
  2651. #endif
  2652.     /* ok, this is a hack, and a big memory leak. should be fixed. - alex */
  2653.     {
  2654. int hand;
  2655. WINE_MODREF *wm;
  2656. void *func;
  2658. hand = LoadLibraryA(library);
  2659. if (!hand)
  2660.     goto no_dll_byname;
  2661. wm = MODULE32_LookupHMODULE(hand);
  2662. if (!wm)
  2663. {
  2664.     FreeLibrary(hand);
  2665.     goto no_dll_byname;
  2666. }
  2667. func = PE_FindExportedFunction(wm, name, 0);
  2668. if (!func)
  2669. {
  2670.     printf("No such name in external dlln");
  2671.     FreeLibrary((int)hand);
  2672.     goto no_dll_byname;
  2673. }
  2675. printf("External dll loaded (offset: 0x%x, func: %p)n",
  2676.        hand, func);
  2677. return func;
  2678.     }
  2680. no_dll_byname:
  2681.     if(pos>150)return 0;// to many symbols
  2682.     strcpy(export_names[pos], name);
  2683.     return add_stub();
  2684. }
  2686. void my_garbagecollection(void)
  2687. {
  2688. #ifdef GARBAGE
  2689.     int unfree = 0, unfreecnt = 0;
  2691.     int max_fatal = 8;
  2692.     free_registry();
  2693.     while (last_alloc)
  2694.     {
  2695. alloc_header* mem = last_alloc + 1;
  2696. unfree += my_size(mem);
  2697. unfreecnt++;
  2698. if (my_release(mem) != 0)
  2699.     // avoid endless loop when memory is trashed
  2700.     if (--max_fatal < 0)
  2701. break;
  2702.     }
  2703.     dbgprintf("Total Unfree %d bytes cnt %d [%p,%d]n",unfree, unfreecnt, last_alloc, alccnt);
  2704. #endif
  2705.     g_tls = NULL;
  2706.     list = NULL;
  2707. }