?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Second attempt to fix compilation of dvdread (I don't really like this but it might...
[vlc/asuraparaju-public.git] / libs / loader / win32.c
blob7f4acf121296f902d385b21ad02325ddfe536df4
1 /*
2 * $Id$
3 *
4 * Originally distributed under LPGL 2.1 (or later) by the Wine project.
5 *
6 * Modified for use with MPlayer, detailed CVS changelog at
7 * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
8 *
9 * File now distributed as part of VLC media player with no modifications.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 */
25
26 /***********************************************************
27
28 Win32 emulation code. Functions that emulate
29 responses from corresponding Win32 API calls.
30 Since we are not going to be able to load
31 virtually any DLL, we can only implement this
32 much, adding needed functions with each new codec.
33
34 Basic principle of implementation: it's not good
35 for DLL to know too much about its environment.
36
37 ************************************************************/
38
39 #include "config.h"
40
41 #ifdef MPLAYER
42 #ifdef USE_QTX_CODECS
43 #define QTX
44 #endif
45 #define REALPLAYER
46 //#define LOADLIB_TRY_NATIVE
47 #endif
48
49 #ifdef QTX
50 #define PSEUDO_SCREEN_WIDTH /*640*/800
51 #define PSEUDO_SCREEN_HEIGHT /*480*/600
52 #endif
53
54 #include "wine/winbase.h"
55 #include "wine/winreg.h"
56 #include "wine/winnt.h"
57 #include "wine/winerror.h"
58 #include "wine/debugtools.h"
59 #include "wine/module.h"
60 #include "wine/winuser.h"
61
62 #include <stdio.h>
63 #include "win32.h"
64
65 #include "registry.h"
66 #include "loader.h"
67 #include "com.h"
68 #include "ext.h"
69
70 #include <stdlib.h>
71 #include <assert.h>
72 #include <stdarg.h>
73 #include <ctype.h>
74 #include <pthread.h>
75 #include <errno.h>
76 #ifdef HAVE_MALLOC_H
77 #include <malloc.h>
78 #endif
79 #include <time.h>
80 #include <math.h>
81 #include <unistd.h>
82 #include <fcntl.h>
83 #include <sys/types.h>
84 #include <dirent.h>
85 #include <sys/time.h>
86 #include <sys/timeb.h>
87 #ifdef HAVE_KSTAT
88 #include <kstat.h>
89 #endif
90
91 #if HAVE_VSSCANF
92 int vsscanf( const char *str, const char *format, va_list ap);
93 #else
94 /* system has no vsscanf. try to provide one */
95 static int vsscanf( const char *str, const char *format, va_list ap)
96 {
97 long p1 = va_arg(ap, long);
98 long p2 = va_arg(ap, long);
99 long p3 = va_arg(ap, long);
100 long p4 = va_arg(ap, long);
101 long p5 = va_arg(ap, long);
102 return sscanf(str, format, p1, p2, p3, p4, p5);
103 }
104 #endif
105
106 static char* def_path = WIN32_PATH;
107
108 static void do_cpuid(unsigned int ax, unsigned int *regs)
109 {
110 __asm__ __volatile__
111 (
112 "pushl %%ebx; pushl %%ecx; pushl %%edx;"
113 ".byte 0x0f, 0xa2;"
114 "movl %%eax, (%2);"
115 "movl %%ebx, 4(%2);"
116 "movl %%ecx, 8(%2);"
117 "movl %%edx, 12(%2);"
118 "popl %%edx; popl %%ecx; popl %%ebx;"
119 : "=a" (ax)
120 : "0" (ax), "S" (regs)
121 );
122 }
123 static unsigned int c_localcount_tsc()
124 {
125 int a;
126 __asm__ __volatile__
127 (
128 "rdtsc\n\t"
129 :"=a"(a)
130 :
131 :"edx"
132 );
133 return a;
134 }
135 static void c_longcount_tsc(long long* z)
136 {
137 __asm__ __volatile__
138 (
139 "pushl %%ebx\n\t"
140 "movl %%eax, %%ebx\n\t"
141 "rdtsc\n\t"
142 "movl %%eax, 0(%%ebx)\n\t"
143 "movl %%edx, 4(%%ebx)\n\t"
144 "popl %%ebx\n\t"
145 ::"a"(z)
146 :"edx"
147 );
148 }
149 static unsigned int c_localcount_notsc()
150 {
151 struct timeval tv;
152 unsigned limit=~0;
153 limit/=1000000;
154 gettimeofday(&tv, 0);
155 return limit*tv.tv_usec;
156 }
157 static void c_longcount_notsc(long long* z)
158 {
159 struct timeval tv;
160 unsigned long long result;
161 unsigned limit=~0;
162 if(!z)return;
163 limit/=1000000;
164 gettimeofday(&tv, 0);
165 result=tv.tv_sec;
166 result<<=32;
167 result+=limit*tv.tv_usec;
168 *z=result;
169 }
170 static unsigned int localcount_stub(void);
171 static void longcount_stub(long long*);
172 static unsigned int (*localcount)()=localcount_stub;
173 static void (*longcount)(long long*)=longcount_stub;
174
175 static pthread_mutex_t memmut;
176
177 static unsigned int localcount_stub(void)
178 {
179 unsigned int regs[4];
180 do_cpuid(1, regs);
181 if ((regs[3] & 0x00000010) != 0)
182 {
183 localcount=c_localcount_tsc;
184 longcount=c_longcount_tsc;
185 }
186 else
187 {
188 localcount=c_localcount_notsc;
189 longcount=c_longcount_notsc;
190 }
191 return localcount();
192 }
193 static void longcount_stub(long long* z)
194 {
195 unsigned int regs[4];
196 do_cpuid(1, regs);
197 if ((regs[3] & 0x00000010) != 0)
198 {
199 localcount=c_localcount_tsc;
200 longcount=c_longcount_tsc;
201 }
202 else
203 {
204 localcount=c_localcount_notsc;
205 longcount=c_longcount_notsc;
206 }
207 longcount(z);
208 }
209
210 #ifdef MPLAYER
211 #include "../mp_msg.h"
212 #endif
213 int LOADER_DEBUG=1; // active only if compiled with -DDETAILED_OUT
214 //#define DETAILED_OUT
215 static inline void dbgprintf(const char* fmt, ...)
216 {
217 #ifdef DETAILED_OUT
218 if(LOADER_DEBUG)
219 {
220 FILE* f;
221 va_list va;
222 va_start(va, fmt);
223 f=fopen("./log", "a");
224 vprintf(fmt, va);
225 fflush(stdout);
226 if(f)
227 {
228 vfprintf(f, fmt, va);
229 fsync(fileno(f));
230 fclose(f);
231 }
232 va_end(va);
233 }
234 #endif
235 #ifdef MPLAYER
236 if (verbose > 2)
237 {
238 va_list va;
239
240 va_start(va, fmt);
241 vprintf(fmt, va);
242 // mp_dbg(MSGT_WIN32, MSGL_DBG3, fmt, va);
243 va_end(va);
244 }
245 fflush(stdout);
246 #endif
247 }
248
249
250 char export_names[300][32]={
251 "name1",
252 //"name2",
253 //"name3"
254 };
255 //#define min(x,y) ((x)<(y)?(x):(y))
256
257 void destroy_event(void* event);
258
259 struct th_list_t;
260 typedef struct th_list_t{
261 int id;
262 void* thread;
263 struct th_list_t* next;
264 struct th_list_t* prev;
265 } th_list;
266
267
268 // have to be cleared by GARBAGE COLLECTOR
269 static unsigned char* heap=NULL;
270 static int heap_counter=0;
271 static tls_t* g_tls=NULL;
272 static th_list* list=NULL;
273
274 static void test_heap(void)
275 {
276 int offset=0;
277 if(heap==0)
278 return;
279 while(offset<heap_counter)
280 {
281 if(*(int*)(heap+offset)!=0x433476)
282 {
283 printf("Heap corruption at address %d\n", offset);
284 return;
285 }
286 offset+=8+*(int*)(heap+offset+4);
287 }
288 for(;offset<min(offset+1000, 20000000); offset++)
289 if(heap[offset]!=0xCC)
290 {
291 printf("Free heap corruption at address %d\n", offset);
292 }
293 }
294 #undef MEMORY_DEBUG
295
296 #ifdef MEMORY_DEBUG
297
298 static void* my_mreq(int size, int to_zero)
299 {
300 static int test=0;
301 test++;
302 if(test%10==0)printf("Memory: %d bytes allocated\n", heap_counter);
303 // test_heap();
304 if(heap==NULL)
305 {
306 heap=malloc(20000000);
307 memset(heap, 0xCC,20000000);
308 }
309 if(heap==0)
310 {
311 printf("No enough memory\n");
312 return 0;
313 }
314 if(heap_counter+size>20000000)
315 {
316 printf("No enough memory\n");
317 return 0;
318 }
319 *(int*)(heap+heap_counter)=0x433476;
320 heap_counter+=4;
321 *(int*)(heap+heap_counter)=size;
322 heap_counter+=4;
323 printf("Allocated %d bytes of memory: sys %d, user %d-%d\n", size, heap_counter-8, heap_counter, heap_counter+size);
324 if(to_zero)
325 memset(heap+heap_counter, 0, size);
326 else
327 memset(heap+heap_counter, 0xcc, size); // make crash reproducable
328 heap_counter+=size;
329 return heap+heap_counter-size;
330 }
331 static int my_release(char* memory)
332 {
333 // test_heap();
334 if(memory==NULL)
335 {
336 printf("ERROR: free(0)\n");
337 return 0;
338 }
339 if(*(int*)(memory-8)!=0x433476)
340 {
341 printf("MEMORY CORRUPTION !!!!!!!!!!!!!!!!!!!\n");
342 return 0;
343 }
344 printf("Freed %d bytes of memory\n", *(int*)(memory-4));
345 // memset(memory-8, *(int*)(memory-4), 0xCC);
346 return 0;
347 }
348
349 #else
350 #define GARBAGE
351 typedef struct alloc_header_t alloc_header;
352 struct alloc_header_t
353 {
354 // let's keep allocated data 16 byte aligned
355 alloc_header* prev;
356 alloc_header* next;
357 long deadbeef;
358 long size;
359 long type;
360 long reserved1;
361 long reserved2;
362 long reserved3;
363 };
364
365 #ifdef GARBAGE
366 static alloc_header* last_alloc = NULL;
367 static int alccnt = 0;
368 #endif
369
370 #define AREATYPE_CLIENT 0
371 #define AREATYPE_EVENT 1
372 #define AREATYPE_MUTEX 2
373 #define AREATYPE_COND 3
374 #define AREATYPE_CRITSECT 4
375
376 /* -- critical sections -- */
377 struct CRITSECT
378 {
379 pthread_t id;
380 pthread_mutex_t mutex;
381 int locked;
382 long deadbeef;
383 };
384
385 void* mreq_private(int size, int to_zero, int type);
386 void* mreq_private(int size, int to_zero, int type)
387 {
388 int nsize = size + sizeof(alloc_header);
389 alloc_header* header = (alloc_header* ) malloc(nsize);
390 if (!header)
391 return 0;
392 if (to_zero)
393 memset(header, 0, nsize);
394 #ifdef GARBAGE
395 if (!last_alloc)
396 {
397 pthread_mutex_init(&memmut, NULL);
398 pthread_mutex_lock(&memmut);
399 }
400 else
401 {
402 pthread_mutex_lock(&memmut);
403 last_alloc->next = header; /* set next */
404 }
405
406 header->prev = last_alloc;
407 header->next = 0;
408 last_alloc = header;
409 alccnt++;
410 pthread_mutex_unlock(&memmut);
411 #endif
412 header->deadbeef = 0xdeadbeef;
413 header->size = size;
414 header->type = type;
415
416 //if (alccnt < 40000) printf("MY_REQ: %p\t%d t:%d (cnt:%d)\n", header, size, type, alccnt);
417 return header + 1;
418 }
419
420 static int my_release(void* memory)
421 {
422 alloc_header* header = (alloc_header*) memory - 1;
423 #ifdef GARBAGE
424 alloc_header* prevmem;
425 alloc_header* nextmem;
426
427 if (memory == 0)
428 return 0;
429
430 if (header->deadbeef != (long) 0xdeadbeef)
431 {
432 dbgprintf("FATAL releasing corrupted memory! %p 0x%lx (%d)\n", header, header->deadbeef, alccnt);
433 return 0;
434 }
435
436 pthread_mutex_lock(&memmut);
437
438 switch(header->type)
439 {
440 case AREATYPE_EVENT:
441 destroy_event(memory);
442 break;
443 case AREATYPE_COND:
444 pthread_cond_destroy((pthread_cond_t*)memory);
445 break;
446 case AREATYPE_MUTEX:
447 pthread_mutex_destroy((pthread_mutex_t*)memory);
448 break;
449 case AREATYPE_CRITSECT:
450 pthread_mutex_destroy(&((struct CRITSECT*)memory)->mutex);
451 break;
452 default:
453 //memset(memory, 0xcc, header->size);
454 ;
455 }
456
457 header->deadbeef = 0;
458 prevmem = header->prev;
459 nextmem = header->next;
460
461 if (prevmem)
462 prevmem->next = nextmem;
463 if (nextmem)
464 nextmem->prev = prevmem;
465
466 if (header == last_alloc)
467 last_alloc = prevmem;
468
469 alccnt--;
470
471 if (last_alloc)
472 pthread_mutex_unlock(&memmut);
473 else
474 pthread_mutex_destroy(&memmut);
475
476 //if (alccnt < 40000) printf("MY_RELEASE: %p\t%ld (%d)\n", header, header->size, alccnt);
477 #else
478 if (memory == 0)
479 return 0;
480 #endif
481 //memset(header + 1, 0xcc, header->size);
482 free(header);
483 return 0;
484 }
485 #endif
486
487 static inline void* my_mreq(int size, int to_zero)
488 {
489 return mreq_private(size, to_zero, AREATYPE_CLIENT);
490 }
491
492 static int my_size(void* memory)
493 {
494 if(!memory) return 0;
495 return ((alloc_header*)memory)[-1].size;
496 }
497
498 static void* my_realloc(void* memory, int size)
499 {
500 void *ans = memory;
501 int osize;
502 if (memory == NULL)
503 return my_mreq(size, 0);
504 osize = my_size(memory);
505 if (osize < size)
506 {
507 ans = my_mreq(size, 0);
508 memcpy(ans, memory, osize);
509 my_release(memory);
510 }
511 return ans;
512 }
513
514 /*
515 *
516 * WINE API - native implementation for several win32 libraries
517 *
518 */
519
520 static int WINAPI ext_unknown()
521 {
522 printf("Unknown func called\n");
523 return 0;
524 }
525
526 static int WINAPI expGetVolumeInformationA( const char *root, char *label,
527 unsigned int label_len, unsigned int *serial,
528 unsigned int *filename_len,unsigned int *flags,
529 char *fsname, unsigned int fsname_len )
530 {
531 dbgprintf("GetVolumeInformationA( %s, 0x%x, %ld, 0x%x, 0x%x, 0x%x, 0x%x, %ld) => 1\n",
532 root,label,label_len,serial,filename_len,flags,fsname,fsname_len);
533 //hack Do not return any real data - do nothing
534 return 1;
535 }
536
537 static unsigned int WINAPI expGetDriveTypeA( const char *root )
538 {
539 dbgprintf("GetDriveTypeA( %s ) => %d\n",root,DRIVE_FIXED);
540 // hack return as Fixed Drive Type
541 return DRIVE_FIXED;
542 }
543
544 static unsigned int WINAPI expGetLogicalDriveStringsA( unsigned int len, char *buffer )
545 {
546 dbgprintf("GetLogicalDriveStringsA(%d, 0x%x) => 4\n",len,buffer);
547 // hack only have one drive c:\ in this hack
548 *buffer++='c';
549 *buffer++=':';
550 *buffer++='\\';
551 *buffer++='\0';
552 *buffer= '\0';
553 return 4; // 1 drive * 4 bytes (includes null)
554 }
555
556
557 static int WINAPI expIsBadWritePtr(void* ptr, unsigned int count)
558 {
559 int result = (count == 0 || ptr != 0) ? 0 : 1;
560 dbgprintf("IsBadWritePtr(0x%x, 0x%x) => %d\n", ptr, count, result);
561 return result;
562 }
563 static int WINAPI expIsBadReadPtr(void* ptr, unsigned int count)
564 {
565 int result = (count == 0 || ptr != 0) ? 0 : 1;
566 dbgprintf("IsBadReadPtr(0x%x, 0x%x) => %d\n", ptr, count, result);
567 return result;
568 }
569 static int WINAPI expDisableThreadLibraryCalls(int module)
570 {
571 dbgprintf("DisableThreadLibraryCalls(0x%x) => 0\n", module);
572 return 0;
573 }
574
575 static HMODULE WINAPI expGetDriverModuleHandle(DRVR* pdrv)
576 {
577 HMODULE result;
578 if (pdrv==NULL)
579 result=0;
580 else
581 result=pdrv->hDriverModule;
582 dbgprintf("GetDriverModuleHandle(%p) => %p\n", pdrv, result);
583 return result;
584 }
585
586 #define MODULE_HANDLE_kernel32 ((HMODULE)0x120)
587 #define MODULE_HANDLE_user32 ((HMODULE)0x121)
588 #ifdef QTX
589 #define MODULE_HANDLE_wininet ((HMODULE)0x122)
590 #define MODULE_HANDLE_ddraw ((HMODULE)0x123)
591 #define MODULE_HANDLE_advapi32 ((HMODULE)0x124)
592 #endif
593 #define MODULE_HANDLE_comdlg32 ((HMODULE)0x125)
594 #define MODULE_HANDLE_msvcrt ((HMODULE)0x126)
595 #define MODULE_HANDLE_ole32 ((HMODULE)0x127)
596 #define MODULE_HANDLE_winmm ((HMODULE)0x128)
597
598 static HMODULE WINAPI expGetModuleHandleA(const char* name)
599 {
600 WINE_MODREF* wm;
601 HMODULE result;
602 if(!name)
603 #ifdef QTX
604 result=1;
605 #else
606 result=0;
607 #endif
608 else
609 {
610 wm=MODULE_FindModule(name);
611 if(wm==0)result=0;
612 else
613 result=(HMODULE)(wm->module);
614 }
615 if(!result)
616 {
617 if(name && (strcasecmp(name, "kernel32")==0 || !strcasecmp(name, "kernel32.dll")))
618 result=MODULE_HANDLE_kernel32;
619 #ifdef QTX
620 if(name && strcasecmp(name, "user32")==0)
621 result=MODULE_HANDLE_user32;
622 #endif
623 }
624 dbgprintf("GetModuleHandleA('%s') => 0x%x\n", name, result);
625 return result;
626 }
627
628 static void* WINAPI expCreateThread(void* pSecAttr, long dwStackSize,
629 void* lpStartAddress, void* lpParameter,
630 long dwFlags, long* dwThreadId)
631 {
632 pthread_t *pth;
633 // printf("CreateThread:");
634 pth = (pthread_t*) my_mreq(sizeof(pthread_t), 0);
635 pthread_create(pth, NULL, (void*(*)(void*))lpStartAddress, lpParameter);
636 if(dwFlags)
637 printf( "WARNING: CreateThread flags not supported\n");
638 if(dwThreadId)
639 *dwThreadId=(long)pth;
640 if(list==NULL)
641 {
642 list=my_mreq(sizeof(th_list), 1);
643 list->next=list->prev=NULL;
644 }
645 else
646 {
647 list->next=my_mreq(sizeof(th_list), 0);
648 list->next->prev=list;
649 list->next->next=NULL;
650 list=list->next;
651 }
652 list->thread=pth;
653 dbgprintf("CreateThread(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) => 0x%x\n",
654 pSecAttr, dwStackSize, lpStartAddress, lpParameter, dwFlags, dwThreadId, pth);
655 return pth;
656 }
657
658 struct mutex_list_t;
659
660 struct mutex_list_t
661 {
662 char type;
663 pthread_mutex_t *pm;
664 pthread_cond_t *pc;
665 char state;
666 char reset;
667 char name[128];
668 int semaphore;
669 struct mutex_list_t* next;
670 struct mutex_list_t* prev;
671 };
672 typedef struct mutex_list_t mutex_list;
673 static mutex_list* mlist=NULL;
674
675 void destroy_event(void* event)
676 {
677 mutex_list* pp=mlist;
678 // printf("garbage collector: destroy_event(%x)\n", event);
679 while(pp)
680 {
681 if(pp==(mutex_list*)event)
682 {
683 if(pp->next)
684 pp->next->prev=pp->prev;
685 if(pp->prev)
686 pp->prev->next=pp->next;
687 if(mlist==(mutex_list*)event)
688 mlist=mlist->prev;
689 /*
690 pp=mlist;
691 while(pp)
692 {
693 printf("%x => ", pp);
694 pp=pp->prev;
695 }
696 printf("0\n");
697 */
698 return;
699 }
700 pp=pp->prev;
701 }
702 }
703
704 static void* WINAPI expCreateEventA(void* pSecAttr, char bManualReset,
705 char bInitialState, const char* name)
706 {
707 pthread_mutex_t *pm;
708 pthread_cond_t *pc;
709 /*
710 mutex_list* pp;
711 pp=mlist;
712 while(pp)
713 {
714 printf("%x => ", pp);
715 pp=pp->prev;
716 }
717 printf("0\n");
718 */
719 if(mlist!=NULL)
720 {
721 mutex_list* pp=mlist;
722 if(name!=NULL)
723 do
724 {
725 if((strcmp(pp->name, name)==0) && (pp->type==0))
726 {
727 dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, 0x%x='%s') => 0x%x\n",
728 pSecAttr, bManualReset, bInitialState, name, name, pp->pm);
729 return pp->pm;
730 }
731 }while((pp=pp->prev) != NULL);
732 }
733 pm=mreq_private(sizeof(pthread_mutex_t), 0, AREATYPE_MUTEX);
734 pthread_mutex_init(pm, NULL);
735 pc=mreq_private(sizeof(pthread_cond_t), 0, AREATYPE_COND);
736 pthread_cond_init(pc, NULL);
737 if(mlist==NULL)
738 {
739 mlist=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT);
740 mlist->next=mlist->prev=NULL;
741 }
742 else
743 {
744 mlist->next=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT);
745 mlist->next->prev=mlist;
746 mlist->next->next=NULL;
747 mlist=mlist->next;
748 }
749 mlist->type=0; /* Type Event */
750 mlist->pm=pm;
751 mlist->pc=pc;
752 mlist->state=bInitialState;
753 mlist->reset=bManualReset;
754 if(name)
755 strncpy(mlist->name, name, 127);
756 else
757 mlist->name[0]=0;
758 if(pm==NULL)
759 dbgprintf("ERROR::: CreateEventA failure\n");
760 /*
761 if(bInitialState)
762 pthread_mutex_lock(pm);
763 */
764 if(name)
765 dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, 0x%x='%s') => 0x%x\n",
766 pSecAttr, bManualReset, bInitialState, name, name, mlist);
767 else
768 dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, NULL) => 0x%x\n",
769 pSecAttr, bManualReset, bInitialState, mlist);
770 return mlist;
771 }
772
773 static void* WINAPI expSetEvent(void* event)
774 {
775 mutex_list *ml = (mutex_list *)event;
776 dbgprintf("SetEvent(%x) => 0x1\n", event);
777 pthread_mutex_lock(ml->pm);
778 if (ml->state == 0) {
779 ml->state = 1;
780 pthread_cond_signal(ml->pc);
781 }
782 pthread_mutex_unlock(ml->pm);
783
784 return (void *)1;
785 }
786 static void* WINAPI expResetEvent(void* event)
787 {
788 mutex_list *ml = (mutex_list *)event;
789 dbgprintf("ResetEvent(0x%x) => 0x1\n", event);
790 pthread_mutex_lock(ml->pm);
791 ml->state = 0;
792 pthread_mutex_unlock(ml->pm);
793
794 return (void *)1;
795 }
796
797 static void* WINAPI expWaitForSingleObject(void* object, int duration)
798 {
799 mutex_list *ml = (mutex_list *)object;
800 // FIXME FIXME FIXME - this value is sometime unititialize !!!
801 int ret = WAIT_FAILED;
802 mutex_list* pp=mlist;
803 if(object == (void*)0xcfcf9898)
804 {
805 /**
806 From GetCurrentThread() documentation:
807 A pseudo handle is a special constant that is interpreted as the current thread handle. The calling thread can use this handle to specify itself whenever a thread handle is required. Pseudo handles are not inherited by child processes.
808
809 This handle has the maximum possible access to the thread object. For systems that support security descriptors, this is the maximum access allowed by the security descriptor for the calling process. For systems that do not support security descriptors, this is THREAD_ALL_ACCESS.
810
811 The function cannot be used by one thread to create a handle that can be used by other threads to refer to the first thread. The handle is always interpreted as referring to the thread that is using it. A thread can create a "real" handle to itself that can be used by other threads, or inherited by other processes, by specifying the pseudo handle as the source handle in a call to the DuplicateHandle function.
812 **/
813 dbgprintf("WaitForSingleObject(thread_handle) called\n");
814 return (void*)WAIT_FAILED;
815 }
816 dbgprintf("WaitForSingleObject(0x%x, duration %d) =>\n",object, duration);
817
818 // loop below was slightly fixed - its used just for checking if
819 // this object really exists in our list
820 if (!ml)
821 return (void*) ret;
822 while (pp && (pp->pm != ml->pm))
823 pp = pp->prev;
824 if (!pp) {
825 dbgprintf("WaitForSingleObject: NotFound\n");
826 return (void*)ret;
827 }
828
829 pthread_mutex_lock(ml->pm);
830
831 switch(ml->type) {
832 case 0: /* Event */
833 if (duration == 0) { /* Check Only */
834 if (ml->state == 1) ret = WAIT_FAILED;
835 else ret = WAIT_OBJECT_0;
836 }
837 if (duration == -1) { /* INFINITE */
838 if (ml->state == 0)
839 pthread_cond_wait(ml->pc,ml->pm);
840 if (ml->reset)
841 ml->state = 0;
842 ret = WAIT_OBJECT_0;
843 }
844 if (duration > 0) { /* Timed Wait */
845 struct timespec abstime;
846 struct timeval now;
847 gettimeofday(&now, 0);
848 abstime.tv_sec = now.tv_sec + (now.tv_usec+duration)/1000000;
849 abstime.tv_nsec = ((now.tv_usec+duration)%1000000)*1000;
850 if (ml->state == 0)
851 ret=pthread_cond_timedwait(ml->pc,ml->pm,&abstime);
852 if (ret == ETIMEDOUT) ret = WAIT_TIMEOUT;
853 else ret = WAIT_OBJECT_0;
854 if (ml->reset)
855 ml->state = 0;
856 }
857 break;
858 case 1: /* Semaphore */
859 if (duration == 0) {
860 if(ml->semaphore==0) ret = WAIT_FAILED;
861 else {
862 ml->semaphore++;
863 ret = WAIT_OBJECT_0;
864 }
865 }
866 if (duration == -1) {
867 if (ml->semaphore==0)
868 pthread_cond_wait(ml->pc,ml->pm);
869 ml->semaphore--;
870 }
871 break;
872 }
873 pthread_mutex_unlock(ml->pm);
874
875 dbgprintf("WaitForSingleObject(0x%x, %d): 0x%x => 0x%x \n",object,duration,ml,ret);
876 return (void *)ret;
877 }
878
879 #ifdef QTX
880 static void* WINAPI expWaitForMultipleObjects(int count, const void** objects,
881 int WaitAll, int duration)
882 {
883 int i;
884 void *object;
885 void *ret;
886
887 dbgprintf("WaitForMultipleObjects(%d, 0x%x, %d, duration %d) =>\n",
888 count, objects, WaitAll, duration);
889
890 for (i = 0; i < count; i++)
891 {
892 object = (void *)objects[i];
893 ret = expWaitForSingleObject(object, duration);
894 if (WaitAll)
895 dbgprintf("WaitAll flag not yet supported...\n");
896 else
897 return ret;
898 }
899 return NULL;
900 }
901
902 static void WINAPI expExitThread(int retcode)
903 {
904 dbgprintf("ExitThread(%d)\n", retcode);
905 pthread_exit(&retcode);
906 }
907
908 static HANDLE WINAPI expCreateMutexA(void *pSecAttr,
909 char bInitialOwner, const char *name)
910 {
911 HANDLE mlist = (HANDLE)expCreateEventA(pSecAttr, 0, 0, name);
912
913 if (name)
914 dbgprintf("CreateMutexA(0x%x, %d, '%s') => 0x%x\n",
915 pSecAttr, bInitialOwner, name, mlist);
916 else
917 dbgprintf("CreateMutexA(0x%x, %d, NULL) => 0x%x\n",
918 pSecAttr, bInitialOwner, mlist);
919 #ifndef QTX
920 /* 10l to QTX, if CreateMutex returns a real mutex, WaitForSingleObject
921 waits for ever, else it works ;) */
922 return mlist;
923 #endif
924 }
925
926 static int WINAPI expReleaseMutex(HANDLE hMutex)
927 {
928 dbgprintf("ReleaseMutex(%x) => 1\n", hMutex);
929 /* FIXME:XXX !! not yet implemented */
930 return 1;
931 }
932 #endif
933
934 static int pf_set = 0;
935 static BYTE PF[64] = {0,};
936
937 static void DumpSystemInfo(const SYSTEM_INFO* si)
938 {
939 dbgprintf(" Processor architecture %d\n", si->u.s.wProcessorArchitecture);
940 dbgprintf(" Page size: %d\n", si->dwPageSize);
941 dbgprintf(" Minimum app address: %d\n", si->lpMinimumApplicationAddress);
942 dbgprintf(" Maximum app address: %d\n", si->lpMaximumApplicationAddress);
943 dbgprintf(" Active processor mask: 0x%x\n", si->dwActiveProcessorMask);
944 dbgprintf(" Number of processors: %d\n", si->dwNumberOfProcessors);
945 dbgprintf(" Processor type: 0x%x\n", si->dwProcessorType);
946 dbgprintf(" Allocation granularity: 0x%x\n", si->dwAllocationGranularity);
947 dbgprintf(" Processor level: 0x%x\n", si->wProcessorLevel);
948 dbgprintf(" Processor revision: 0x%x\n", si->wProcessorRevision);
949 }
950
951 static void WINAPI expGetSystemInfo(SYSTEM_INFO* si)
952 {
953 /* FIXME: better values for the two entries below... */
954 static int cache = 0;
955 static SYSTEM_INFO cachedsi;
956 unsigned int regs[4];
957 dbgprintf("GetSystemInfo(%p) =>\n", si);
958
959 if (cache) {
960 memcpy(si,&cachedsi,sizeof(*si));
961 DumpSystemInfo(si);
962 return;
963 }
964 memset(PF,0,sizeof(PF));
965 pf_set = 1;
966
967 cachedsi.u.s.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
968 cachedsi.dwPageSize = getpagesize();
969
970 /* FIXME: better values for the two entries below... */
971 cachedsi.lpMinimumApplicationAddress = (void *)0x00000000;
972 cachedsi.lpMaximumApplicationAddress = (void *)0x7FFFFFFF;
973 cachedsi.dwActiveProcessorMask = 1;
974 cachedsi.dwNumberOfProcessors = 1;
975 cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
976 cachedsi.dwAllocationGranularity = 0x10000;
977 cachedsi.wProcessorLevel = 5; /* pentium */
978 cachedsi.wProcessorRevision = 0x0101;
979
980 #ifdef MPLAYER
981 /* mplayer's way to detect PF's */
982 {
983 #include "../cpudetect.h"
984 extern CpuCaps gCpuCaps;
985
986 if (gCpuCaps.hasMMX)
987 PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE;
988 if (gCpuCaps.hasSSE)
989 PF[PF_XMMI_INSTRUCTIONS_AVAILABLE] = TRUE;
990 if (gCpuCaps.has3DNow)
991 PF[PF_AMD3D_INSTRUCTIONS_AVAILABLE] = TRUE;
992
993 if (gCpuCaps.cpuType == 4)
994 {
995 cachedsi.dwProcessorType = PROCESSOR_INTEL_486;
996 cachedsi.wProcessorLevel = 4;
997 }
998 else if (gCpuCaps.cpuType >= 5)
999 {
1000 cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1001 cachedsi.wProcessorLevel = 5;
1002 }
1003 else
1004 {
1005 cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
1006 cachedsi.wProcessorLevel = 3;
1007 }
1008 cachedsi.wProcessorRevision = gCpuCaps.cpuStepping;
1009 cachedsi.dwNumberOfProcessors = 1; /* hardcoded */
1010 }
1011 #endif
1012
1013 /* disable cpuid based detection (mplayer's cpudetect.c does this - see above) */
1014 #ifndef MPLAYER
1015 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__svr4__) || defined(__DragonFly__)
1016 do_cpuid(1, regs);
1017 switch ((regs[0] >> 8) & 0xf) { // cpu family
1018 case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
1019 cachedsi.wProcessorLevel= 3;
1020 break;
1021 case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486;
1022 cachedsi.wProcessorLevel= 4;
1023 break;
1024 case 5: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1025 cachedsi.wProcessorLevel= 5;
1026 break;
1027 case 6: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1028 cachedsi.wProcessorLevel= 5;
1029 break;
1030 default:cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1031 cachedsi.wProcessorLevel= 5;
1032 break;
1033 }
1034 cachedsi.wProcessorRevision = regs[0] & 0xf; // stepping
1035 if (regs[3] & (1 << 8))
1036 PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
1037 if (regs[3] & (1 << 23))
1038 PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE;
1039 if (regs[3] & (1 << 25))
1040 PF[PF_XMMI_INSTRUCTIONS_AVAILABLE] = TRUE;
1041 if (regs[3] & (1 << 31))
1042 PF[PF_AMD3D_INSTRUCTIONS_AVAILABLE] = TRUE;
1043 cachedsi.dwNumberOfProcessors=1;
1044 #endif
1045 #endif /* MPLAYER */
1046
1047 /* MPlayer: linux detection enabled (based on proc/cpuinfo) for checking
1048 fdiv_bug and fpu emulation flags -- alex/MPlayer */
1049 #ifdef __linux__
1050 {
1051 char buf[20];
1052 char line[200];
1053 FILE *f = fopen ("/proc/cpuinfo", "r");
1054
1055 if (!f)
1056 return;
1057 while (fgets(line,200,f)!=NULL) {
1058 char *s,*value;
1059
1060 /* NOTE: the ':' is the only character we can rely on */
1061 if (!(value = strchr(line,':')))
1062 continue;
1063 /* terminate the valuename */
1064 *value++ = '\0';
1065 /* skip any leading spaces */
1066 while (*value==' ') value++;
1067 if ((s=strchr(value,'\n')))
1068 *s='\0';
1069
1070 /* 2.1 method */
1071 if (!lstrncmpiA(line, "cpu family",strlen("cpu family"))) {
1072 if (isdigit (value[0])) {
1073 switch (value[0] - '0') {
1074 case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
1075 cachedsi.wProcessorLevel= 3;
1076 break;
1077 case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486;
1078 cachedsi.wProcessorLevel= 4;
1079 break;
1080 case 5: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1081 cachedsi.wProcessorLevel= 5;
1082 break;
1083 case 6: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1084 cachedsi.wProcessorLevel= 5;
1085 break;
1086 default:cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1087 cachedsi.wProcessorLevel= 5;
1088 break;
1089 }
1090 }
1091 /* set the CPU type of the current processor */
1092 sprintf(buf,"CPU %ld",cachedsi.dwProcessorType);
1093 continue;
1094 }
1095 /* old 2.0 method */
1096 if (!lstrncmpiA(line, "cpu",strlen("cpu"))) {
1097 if ( isdigit (value[0]) && value[1] == '8' &&
1098 value[2] == '6' && value[3] == 0
1099 ) {
1100 switch (value[0] - '0') {
1101 case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
1102 cachedsi.wProcessorLevel= 3;
1103 break;
1104 case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486;
1105 cachedsi.wProcessorLevel= 4;
1106 break;
1107 case 5: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1108 cachedsi.wProcessorLevel= 5;
1109 break;
1110 case 6: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1111 cachedsi.wProcessorLevel= 5;
1112 break;
1113 default:cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1114 cachedsi.wProcessorLevel= 5;
1115 break;
1116 }
1117 }
1118 /* set the CPU type of the current processor */
1119 sprintf(buf,"CPU %ld",cachedsi.dwProcessorType);
1120 continue;
1121 }
1122 if (!lstrncmpiA(line,"fdiv_bug",strlen("fdiv_bug"))) {
1123 if (!lstrncmpiA(value,"yes",3))
1124 PF[PF_FLOATING_POINT_PRECISION_ERRATA] = TRUE;
1125
1126 continue;
1127 }
1128 if (!lstrncmpiA(line,"fpu",strlen("fpu"))) {
1129 if (!lstrncmpiA(value,"no",2))
1130 PF[PF_FLOATING_POINT_EMULATED] = TRUE;
1131
1132 continue;
1133 }
1134 if (!lstrncmpiA(line,"processor",strlen("processor"))) {
1135 /* processor number counts up...*/
1136 unsigned int x;
1137
1138 if (sscanf(value,"%d",&x))
1139 if (x+1>cachedsi.dwNumberOfProcessors)
1140 cachedsi.dwNumberOfProcessors=x+1;
1141
1142 /* Create a new processor subkey on a multiprocessor
1143 * system
1144 */
1145 sprintf(buf,"%d",x);
1146 }
1147 if (!lstrncmpiA(line,"stepping",strlen("stepping"))) {
1148 int x;
1149
1150 if (sscanf(value,"%d",&x))
1151 cachedsi.wProcessorRevision = x;
1152 }
1153 if
1154 ( (!lstrncmpiA(line,"flags",strlen("flags")))
1155 || (!lstrncmpiA(line,"features",strlen("features"))) )
1156 {
1157 if (strstr(value,"cx8"))
1158 PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
1159 if (strstr(value,"mmx"))
1160 PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE;
1161 if (strstr(value,"tsc"))
1162 PF[PF_RDTSC_INSTRUCTION_AVAILABLE] = TRUE;
1163 if (strstr(value,"xmm"))
1164 PF[PF_XMMI_INSTRUCTIONS_AVAILABLE] = TRUE;
1165 if (strstr(value,"3dnow"))
1166 PF[PF_AMD3D_INSTRUCTIONS_AVAILABLE] = TRUE;
1167 }
1168 }
1169 fclose (f);
1170 /*
1171 * ad hoc fix for smp machines.
1172 * some problems on WaitForSingleObject,CreateEvent,SetEvent
1173 * CreateThread ...etc..
1174 *
1175 */
1176 cachedsi.dwNumberOfProcessors=1;
1177 }
1178 #endif /* __linux__ */
1179 cache = 1;
1180 memcpy(si,&cachedsi,sizeof(*si));
1181 DumpSystemInfo(si);
1182 }
1183
1184 // avoid undefined expGetSystemInfo
1185 static WIN_BOOL WINAPI expIsProcessorFeaturePresent(DWORD v)
1186 {
1187 WIN_BOOL result = 0;
1188 if (!pf_set)
1189 {
1190 SYSTEM_INFO si;
1191 expGetSystemInfo(&si);
1192 }
1193 if(v<64) result=PF[v];
1194 dbgprintf("IsProcessorFeaturePresent(0x%x) => 0x%x\n", v, result);
1195 return result;
1196 }
1197
1198
1199 static long WINAPI expGetVersion()
1200 {
1201 dbgprintf("GetVersion() => 0xC0000004\n");
1202 return 0xC0000004;//Windows 95
1203 }
1204
1205 static HANDLE WINAPI expHeapCreate(long flags, long init_size, long max_size)
1206 {
1207 // printf("HeapCreate:");
1208 HANDLE result;
1209 if(init_size==0)
1210 result=(HANDLE)my_mreq(0x110000, 0);
1211 else
1212 result=(HANDLE)my_mreq((init_size + 0xfff) & 0x7ffff000 , 0);
1213 dbgprintf("HeapCreate(flags 0x%x, initial size %d, maximum size %d) => 0x%x\n", flags, init_size, max_size, result);
1214 return result;
1215 }
1216
1217 // this is another dirty hack
1218 // VP31 is releasing one allocated Heap chunk twice
1219 // we will silently ignore this second call...
1220 static void* heapfreehack = 0;
1221 static int heapfreehackshown = 0;
1222 //extern void trapbug(void);
1223 static void* WINAPI expHeapAlloc(HANDLE heap, int flags, int size)
1224 {
1225 void* z;
1226 /**
1227 Morgan's m3jpeg32.dll v. 2.0 encoder expects that request for
1228 HeapAlloc returns area larger than size argument :-/
1229
1230 actually according to M$ Doc HeapCreate size should be rounded
1231 to page boundaries thus we should simulate this
1232 **/
1233 //if (size == 22276) trapbug();
1234 z=my_mreq((size + 0xfff) & 0x7ffff000, (flags & HEAP_ZERO_MEMORY));
1235 if(z==0)
1236 printf("HeapAlloc failure\n");
1237 dbgprintf("HeapAlloc(heap 0x%x, flags 0x%x, size %d) => 0x%x\n", heap, flags, size, z);
1238 heapfreehack = 0; // reset
1239 return z;
1240 }
1241 static long WINAPI expHeapDestroy(void* heap)
1242 {
1243 dbgprintf("HeapDestroy(heap 0x%x) => 1\n", heap);
1244 my_release(heap);
1245 return 1;
1246 }
1247
1248 static long WINAPI expHeapFree(HANDLE heap, DWORD dwFlags, LPVOID lpMem)
1249 {
1250 dbgprintf("HeapFree(0x%x, 0x%x, pointer 0x%x) => 1\n", heap, dwFlags, lpMem);
1251 if (heapfreehack != lpMem && lpMem != (void*)0xffffffff
1252 && lpMem != (void*)0xbdbdbdbd)
1253 // 0xbdbdbdbd is for i263_drv.drv && libefence
1254 // it seems to be reading from relased memory
1255 // EF_PROTECT_FREE doens't show any probleme
1256 my_release(lpMem);
1257 else
1258 {
1259 if (!heapfreehackshown++)
1260 printf("Info: HeapFree deallocating same memory twice! (%p)\n", lpMem);
1261 }
1262 heapfreehack = lpMem;
1263 return 1;
1264 }
1265 static long WINAPI expHeapSize(int heap, int flags, void* pointer)
1266 {
1267 long result=my_size(pointer);
1268 dbgprintf("HeapSize(heap 0x%x, flags 0x%x, pointer 0x%x) => %d\n", heap, flags, pointer, result);
1269 return result;
1270 }
1271 static void* WINAPI expHeapReAlloc(HANDLE heap,int flags,void *lpMem,int size)
1272 {
1273 long orgsize = my_size(lpMem);
1274 dbgprintf("HeapReAlloc() Size %ld org %d\n",orgsize,size);
1275 return my_realloc(lpMem, size);
1276 }
1277 static long WINAPI expGetProcessHeap(void)
1278 {
1279 dbgprintf("GetProcessHeap() => 1\n");
1280 return 1;
1281 }
1282 static void* WINAPI expVirtualAlloc(void* v1, long v2, long v3, long v4)
1283 {
1284 void* z = VirtualAlloc(v1, v2, v3, v4);
1285 if(z==0)
1286 printf("VirtualAlloc failure\n");
1287 dbgprintf("VirtualAlloc(0x%x, %d, %d, %d) => 0x%x \n",v1,v2,v3,v4, z);
1288 return z;
1289 }
1290 static int WINAPI expVirtualFree(void* v1, int v2, int v3)
1291 {
1292 int result = VirtualFree(v1,v2,v3);
1293 dbgprintf("VirtualFree(0x%x, %d, %d) => %d\n",v1,v2,v3, result);
1294 return result;
1295 }
1296
1297 /* we're building a table of critical sections. cs_win pointer uses the DLL
1298 cs_unix is the real structure, we're using cs_win only to identifying cs_unix */
1299 struct critsecs_list_t
1300 {
1301 CRITICAL_SECTION *cs_win;
1302 struct CRITSECT *cs_unix;
1303 };
1304
1305 /* 'NEWTYPE' is working with VIVO, 3ivX and QTX dll (no more segfaults) -- alex */
1306 #undef CRITSECS_NEWTYPE
1307 //#define CRITSECS_NEWTYPE 1
1308
1309 #ifdef CRITSECS_NEWTYPE
1310 /* increased due to ucod needs more than 32 entries */
1311 /* and 64 should be enough for everything */
1312 #define CRITSECS_LIST_MAX 64
1313 static struct critsecs_list_t critsecs_list[CRITSECS_LIST_MAX];
1314
1315 static int critsecs_get_pos(CRITICAL_SECTION *cs_win)
1316 {
1317 int i;
1318
1319 for (i=0; i < CRITSECS_LIST_MAX; i++)
1320 if (critsecs_list[i].cs_win == cs_win)
1321 return(i);
1322 return(-1);
1323 }
1324
1325 static int critsecs_get_unused(void)
1326 {
1327 int i;
1328
1329 for (i=0; i < CRITSECS_LIST_MAX; i++)
1330 if (critsecs_list[i].cs_win == NULL)
1331 return(i);
1332 return(-1);
1333 }
1334
1335 struct CRITSECT *critsecs_get_unix(CRITICAL_SECTION *cs_win)
1336 {
1337 int i;
1338
1339 for (i=0; i < CRITSECS_LIST_MAX; i++)
1340 if (critsecs_list[i].cs_win == cs_win && critsecs_list[i].cs_unix)
1341 return(critsecs_list[i].cs_unix);
1342 return(NULL);
1343 }
1344 #endif
1345
1346 static void WINAPI expInitializeCriticalSection(CRITICAL_SECTION* c)
1347 {
1348 dbgprintf("InitializeCriticalSection(0x%x)\n", c);
1349 /* if(sizeof(pthread_mutex_t)>sizeof(CRITICAL_SECTION))
1350 {
1351 printf(" ERROR:::: sizeof(pthread_mutex_t) is %d, expected <=%d!\n",
1352 sizeof(pthread_mutex_t), sizeof(CRITICAL_SECTION));
1353 return;
1354 }*/
1355 /* pthread_mutex_init((pthread_mutex_t*)c, NULL); */
1356 #ifdef CRITSECS_NEWTYPE
1357 {
1358 struct CRITSECT *cs;
1359 int i = critsecs_get_unused();
1360
1361 if (i < 0)
1362 {
1363 printf("InitializeCriticalSection(%p) - no more space in list\n", c);
1364 return;
1365 }
1366 dbgprintf("got unused space at %d\n", i);
1367 cs = malloc(sizeof(struct CRITSECT));
1368 if (!cs)
1369 {
1370 printf("InitializeCriticalSection(%p) - out of memory\n", c);
1371 return;
1372 }
1373 pthread_mutex_init(&cs->mutex, NULL);
1374 cs->locked = 0;
1375 critsecs_list[i].cs_win = c;
1376 critsecs_list[i].cs_unix = cs;
1377 dbgprintf("InitializeCriticalSection -> itemno=%d, cs_win=%p, cs_unix=%p\n",
1378 i, c, cs);
1379 }
1380 #else
1381 {
1382 struct CRITSECT* cs = mreq_private(sizeof(struct CRITSECT) + sizeof(CRITICAL_SECTION),
1383 0, AREATYPE_CRITSECT);
1384 pthread_mutex_init(&cs->mutex, NULL);
1385 cs->locked=0;
1386 cs->deadbeef = 0xdeadbeef;
1387 *(void**)c = cs;
1388 }
1389 #endif
1390 return;
1391 }
1392
1393 static void WINAPI expEnterCriticalSection(CRITICAL_SECTION* c)
1394 {
1395 #ifdef CRITSECS_NEWTYPE
1396 struct CRITSECT* cs = critsecs_get_unix(c);
1397 #else
1398 struct CRITSECT* cs = (*(struct CRITSECT**)c);
1399 #endif
1400 dbgprintf("EnterCriticalSection(0x%x) %p\n",c, cs);
1401 if (!cs)
1402 {
1403 dbgprintf("entered uninitialized critisec!\n");
1404 expInitializeCriticalSection(c);
1405 #ifdef CRITSECS_NEWTYPE
1406 cs=critsecs_get_unix(c);
1407 #else
1408 cs = (*(struct CRITSECT**)c);
1409 #endif
1410 dbgprintf("Win32 Warning: Accessed uninitialized Critical Section (%p)!\n", c);
1411 }
1412 if(cs->locked)
1413 if(cs->id==pthread_self())
1414 return;
1415 pthread_mutex_lock(&(cs->mutex));
1416 cs->locked=1;
1417 cs->id=pthread_self();
1418 return;
1419 }
1420 static void WINAPI expLeaveCriticalSection(CRITICAL_SECTION* c)
1421 {
1422 #ifdef CRITSECS_NEWTYPE
1423 struct CRITSECT* cs = critsecs_get_unix(c);
1424 #else
1425 struct CRITSECT* cs = (*(struct CRITSECT**)c);
1426 #endif
1427 // struct CRITSECT* cs=(struct CRITSECT*)c;
1428 dbgprintf("LeaveCriticalSection(0x%x) 0x%x\n",c, cs);
1429 if (!cs)
1430 {
1431 dbgprintf("Win32 Warning: Leaving uninitialized Critical Section %p!!\n", c);
1432 return;
1433 }
1434 if (cs->locked)
1435 {
1436 cs->locked=0;
1437 pthread_mutex_unlock(&(cs->mutex));
1438 }
1439 else
1440 dbgprintf("Win32 Warning: Unlocking unlocked Critical Section %p!!\n", c);
1441 return;
1442 }
1443
1444 static void expfree(void* mem); /* forward declaration */
1445
1446 static void WINAPI expDeleteCriticalSection(CRITICAL_SECTION *c)
1447 {
1448 #ifdef CRITSECS_NEWTYPE
1449 struct CRITSECT* cs = critsecs_get_unix(c);
1450 #else
1451 struct CRITSECT* cs= (*(struct CRITSECT**)c);
1452 #endif
1453 // struct CRITSECT* cs=(struct CRITSECT*)c;
1454 dbgprintf("DeleteCriticalSection(0x%x)\n",c);
1455
1456 if (!cs)
1457 {
1458 dbgprintf("Win32 Warning: Deleting uninitialized Critical Section %p!!\n", c);
1459 return;
1460 }
1461
1462 if (cs->locked)
1463 {
1464 dbgprintf("Win32 Warning: Deleting unlocked Critical Section %p!!\n", c);
1465 pthread_mutex_unlock(&(cs->mutex));
1466 }
1467
1468 #ifndef GARBAGE
1469 pthread_mutex_destroy(&(cs->mutex));
1470 // released by GarbageCollector in my_relase otherwise
1471 #endif
1472 my_release(cs);
1473 #ifdef CRITSECS_NEWTYPE
1474 {
1475 int i = critsecs_get_pos(c);
1476
1477 if (i < 0)
1478 {
1479 printf("DeleteCriticalSection(%p) error (critsec not found)\n", c);
1480 return;
1481 }
1482
1483 critsecs_list[i].cs_win = NULL;
1484 expfree(critsecs_list[i].cs_unix);
1485 critsecs_list[i].cs_unix = NULL;
1486 dbgprintf("DeleteCriticalSection -> itemno=%d\n", i);
1487 }
1488 #endif
1489 return;
1490 }
1491 static int WINAPI expGetCurrentThreadId()
1492 {
1493 dbgprintf("GetCurrentThreadId() => %d\n", pthread_self());
1494 return pthread_self();
1495 }
1496 static int WINAPI expGetCurrentProcess()
1497 {
1498 dbgprintf("GetCurrentProcess() => %d\n", getpid());
1499 return getpid();
1500 }
1501
1502 #ifdef QTX
1503 // this version is required for Quicktime codecs (.qtx/.qts) to work.
1504 // (they assume some pointers at FS: segment)
1505
1506 extern void* fs_seg;
1507
1508 //static int tls_count;
1509 static int tls_use_map[64];
1510 static int WINAPI expTlsAlloc()
1511 {
1512 int i;
1513 for(i=0; i<64; i++)
1514 if(tls_use_map[i]==0)
1515 {
1516 tls_use_map[i]=1;
1517 dbgprintf("TlsAlloc() => %d\n",i);
1518 return i;
1519 }
1520 dbgprintf("TlsAlloc() => -1 (ERROR)\n");
1521 return -1;
1522 }
1523
1524 //static int WINAPI expTlsSetValue(DWORD index, void* value)
1525 static int WINAPI expTlsSetValue(int index, void* value)
1526 {
1527 dbgprintf("TlsSetValue(%d,0x%x) => 1\n",index,value);
1528 // if((index<0) || (index>64))
1529 if((index>=64))
1530 return 0;
1531 *(void**)((char*)fs_seg+0x88+4*index) = value;
1532 return 1;
1533 }
1534
1535 static void* WINAPI expTlsGetValue(DWORD index)
1536 {
1537 dbgprintf("TlsGetValue(%d)\n",index);
1538 // if((index<0) || (index>64))
1539 if((index>=64)) return NULL;
1540 return *(void**)((char*)fs_seg+0x88+4*index);
1541 }
1542
1543 static int WINAPI expTlsFree(int idx)
1544 {
1545 int index = (int) idx;
1546 dbgprintf("TlsFree(%d)\n",index);
1547 if((index<0) || (index>64))
1548 return 0;
1549 tls_use_map[index]=0;
1550 return 1;
1551 }
1552
1553 #else
1554 struct tls_s {
1555 void* value;
1556 int used;
1557 struct tls_s* prev;
1558 struct tls_s* next;
1559 };
1560
1561 static void* WINAPI expTlsAlloc()
1562 {
1563 if (g_tls == NULL)
1564 {
1565 g_tls=my_mreq(sizeof(tls_t), 0);
1566 g_tls->next=g_tls->prev=NULL;
1567 }
1568 else
1569 {
1570 g_tls->next=my_mreq(sizeof(tls_t), 0);
1571 g_tls->next->prev=g_tls;
1572 g_tls->next->next=NULL;
1573 g_tls=g_tls->next;
1574 }
1575 dbgprintf("TlsAlloc() => 0x%x\n", g_tls);
1576 if (g_tls)
1577 g_tls->value=0; /* XXX For Divx.dll */
1578 return g_tls;
1579 }
1580
1581 static int WINAPI expTlsSetValue(void* idx, void* value)
1582 {
1583 tls_t* index = (tls_t*) idx;
1584 int result;
1585 if(index==0)
1586 result=0;
1587 else
1588 {
1589 index->value=value;
1590 result=1;
1591 }
1592 dbgprintf("TlsSetValue(index 0x%x, value 0x%x) => %d \n", index, value, result );
1593 return result;
1594 }
1595 static void* WINAPI expTlsGetValue(void* idx)
1596 {
1597 tls_t* index = (tls_t*) idx;
1598 void* result;
1599 if(index==0)
1600 result=0;
1601 else
1602 result=index->value;
1603 dbgprintf("TlsGetValue(index 0x%x) => 0x%x\n", index, result);
1604 return result;
1605 }
1606 static int WINAPI expTlsFree(void* idx)
1607 {
1608 tls_t* index = (tls_t*) idx;
1609 int result;
1610 if(index==0)
1611 result=0;
1612 else
1613 {
1614 if(index->next)
1615 index->next->prev=index->prev;
1616 if(index->prev)
1617 index->prev->next=index->next;
1618 if (g_tls == index)
1619 g_tls = index->prev;
1620 my_release((void*)index);
1621 result=1;
1622 }
1623 dbgprintf("TlsFree(index 0x%x) => %d\n", index, result);
1624 return result;
1625 }
1626 #endif
1627
1628 static void* WINAPI expLocalAlloc(int flags, int size)
1629 {
1630 void* z = my_mreq(size, (flags & GMEM_ZEROINIT));
1631 if (z == 0)
1632 printf("LocalAlloc() failed\n");
1633 dbgprintf("LocalAlloc(%d, flags 0x%x) => 0x%x\n", size, flags, z);
1634 return z;
1635 }
1636
1637 static void* WINAPI expLocalReAlloc(int handle,int size, int flags)
1638 {
1639 void *newpointer;
1640 int oldsize;
1641
1642 newpointer=NULL;
1643 if (flags & LMEM_MODIFY) {
1644 dbgprintf("LocalReAlloc MODIFY\n");
1645 return (void *)handle;
1646 }
1647 oldsize = my_size((void *)handle);
1648 newpointer = my_realloc((void *)handle,size);
1649 dbgprintf("LocalReAlloc(%x %d(old %d), flags 0x%x) => 0x%x\n", handle,size,oldsize, flags,newpointer);
1650
1651 return newpointer;
1652 }
1653
1654 static void* WINAPI expLocalLock(void* z)
1655 {
1656 dbgprintf("LocalLock(0x%x) => 0x%x\n", z, z);
1657 return z;
1658 }
1659
1660 static void* WINAPI expGlobalAlloc(int flags, int size)
1661 {
1662 void* z;
1663 dbgprintf("GlobalAlloc(%d, flags 0x%X)\n", size, flags);
1664
1665 z=my_mreq(size, (flags & GMEM_ZEROINIT));
1666 //z=calloc(size, 1);
1667 //z=malloc(size);
1668 if(z==0)
1669 printf("GlobalAlloc() failed\n");
1670 dbgprintf("GlobalAlloc(%d, flags 0x%x) => 0x%x\n", size, flags, z);
1671 return z;
1672 }
1673 static void* WINAPI expGlobalLock(void* z)
1674 {
1675 dbgprintf("GlobalLock(0x%x) => 0x%x\n", z, z);
1676 return z;
1677 }
1678 // pvmjpg20 - but doesn't work anyway
1679 static int WINAPI expGlobalSize(void* amem)
1680 {
1681 int size = 100000;
1682 #ifdef GARBAGE
1683 alloc_header* header = last_alloc;
1684 alloc_header* mem = (alloc_header*) amem - 1;
1685 if (amem == 0)
1686 return 0;
1687 pthread_mutex_lock(&memmut);
1688 while (header)
1689 {
1690 if (header->deadbeef != 0xdeadbeef)
1691 {
1692 dbgprintf("FATAL found corrupted memory! %p 0x%lx (%d)\n", header, header->deadbeef, alccnt);
1693 break;
1694 }
1695
1696 if (header == mem)
1697 {
1698 size = header->size;
1699 break;
1700 }
1701
1702 header = header->prev;
1703 }
1704 pthread_mutex_unlock(&memmut);
1705 #endif
1706
1707 dbgprintf("GlobalSize(0x%x)\n", amem);
1708 return size;
1709 }
1710
1711 static int WINAPI expLoadIconA( long hinstance, char *name )
1712 {
1713 dbgprintf("LoadIconA( %ld, 0x%x ) => 1\n",hinstance,name);
1714 return 1;
1715 }
1716
1717 static int WINAPI expLoadStringA(long instance, long id, void* buf, long size)
1718 {
1719 int result=LoadStringA(instance, id, buf, size);
1720 // if(buf)
1721 dbgprintf("LoadStringA(instance 0x%x, id 0x%x, buffer 0x%x, size %d) => %d ( %s )\n",
1722 instance, id, buf, size, result, buf);
1723 // else
1724 // dbgprintf("LoadStringA(instance 0x%x, id 0x%x, buffer 0x%x, size %d) => %d\n",
1725 // instance, id, buf, size, result);
1726 return result;
1727 }
1728
1729 static long WINAPI expMultiByteToWideChar(long v1, long v2, char* s1, long siz1, short* s2, int siz2)
1730 {
1731 #warning FIXME
1732 int i;
1733 int result;
1734 if(s2==0)
1735 result=1;
1736 else
1737 {
1738 if(siz1>siz2/2)siz1=siz2/2;
1739 for(i=1; i<=siz1; i++)
1740 {
1741 *s2=*s1;
1742 if(!*s1)break;
1743 s2++;
1744 s1++;
1745 }
1746 result=i;
1747 }
1748 if(s1)
1749 dbgprintf("MultiByteToWideChar(codepage %d, flags 0x%x, string 0x%x='%s',"
1750 "size %d, dest buffer 0x%x, dest size %d) => %d\n",
1751 v1, v2, s1, s1, siz1, s2, siz2, result);
1752 else
1753 dbgprintf("MultiByteToWideChar(codepage %d, flags 0x%x, string NULL,"
1754 "size %d, dest buffer 0x%x, dest size %d) =>\n",
1755 v1, v2, siz1, s2, siz2, result);
1756 return result;
1757 }
1758 static void wch_print(const short* str)
1759 {
1760 dbgprintf(" src: ");
1761 while(*str)dbgprintf("%c", *str++);
1762 dbgprintf("\n");
1763 }
1764 static long WINAPI expWideCharToMultiByte(long v1, long v2, short* s1, long siz1,
1765 char* s2, int siz2, char* c3, int* siz3)
1766 {
1767 int result;
1768 dbgprintf("WideCharToMultiByte(codepage %d, flags 0x%x, src 0x%x, src size %d, "
1769 "dest 0x%x, dest size %d, defch 0x%x, used_defch 0x%x)", v1, v2, s1, siz1, s2, siz2, c3, siz3);
1770 result=WideCharToMultiByte(v1, v2, s1, siz1, s2, siz2, c3, siz3);
1771 dbgprintf("=> %d\n", result);
1772 //if(s1)wch_print(s1);
1773 if(s2)dbgprintf(" dest: %s\n", s2);
1774 return result;
1775 }
1776 static long WINAPI expGetVersionExA(OSVERSIONINFOA* c)
1777 {
1778 dbgprintf("GetVersionExA(0x%x) => 1\n");
1779 c->dwOSVersionInfoSize=sizeof(*c);
1780 c->dwMajorVersion=4;
1781 c->dwMinorVersion=0;
1782 c->dwBuildNumber=0x4000457;
1783 #if 1
1784 // leave it here for testing win9x-only codecs
1785 c->dwPlatformId=VER_PLATFORM_WIN32_WINDOWS;
1786 strcpy(c->szCSDVersion, " B");
1787 #else
1788 c->dwPlatformId=VER_PLATFORM_WIN32_NT; // let's not make DLL assume that it can read CR* registers
1789 strcpy(c->szCSDVersion, "Service Pack 3");
1790 #endif
1791 dbgprintf(" Major version: 4\n Minor version: 0\n Build number: 0x4000457\n"
1792 " Platform Id: VER_PLATFORM_WIN32_NT\n Version string: 'Service Pack 3'\n");
1793 return 1;
1794 }
1795 static HANDLE WINAPI expCreateSemaphoreA(char* v1, long init_count,
1796 long max_count, char* name)
1797 {
1798 pthread_mutex_t *pm;
1799 pthread_cond_t *pc;
1800 mutex_list* pp;
1801 /*
1802 printf("CreateSemaphoreA(%p = %s)\n", name, (name ? name : "<null>"));
1803 pp=mlist;
1804 while(pp)
1805 {
1806 printf("%p => ", pp);
1807 pp=pp->prev;
1808 }
1809 printf("0\n");
1810 */
1811 if(mlist!=NULL)
1812 {
1813 mutex_list* pp=mlist;
1814 if(name!=NULL)
1815 do
1816 {
1817 if((strcmp(pp->name, name)==0) && (pp->type==1))
1818 {
1819 dbgprintf("CreateSemaphoreA(0x%x, init_count %d, max_count %d, name 0x%x='%s') => 0x%x\n",
1820 v1, init_count, max_count, name, name, mlist);
1821 return (HANDLE)mlist;
1822 }
1823 }while((pp=pp->prev) != NULL);
1824 }
1825 pm=mreq_private(sizeof(pthread_mutex_t), 0, AREATYPE_MUTEX);
1826 pthread_mutex_init(pm, NULL);
1827 pc=mreq_private(sizeof(pthread_cond_t), 0, AREATYPE_COND);
1828 pthread_cond_init(pc, NULL);
1829 if(mlist==NULL)
1830 {
1831 mlist=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT);
1832 mlist->next=mlist->prev=NULL;
1833 }
1834 else
1835 {
1836 mlist->next=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT);
1837 mlist->next->prev=mlist;
1838 mlist->next->next=NULL;
1839 mlist=mlist->next;
1840 // printf("new semaphore %p\n", mlist);
1841 }
1842 mlist->type=1; /* Type Semaphore */
1843 mlist->pm=pm;
1844 mlist->pc=pc;
1845 mlist->state=0;
1846 mlist->reset=0;
1847 mlist->semaphore=init_count;
1848 if(name!=NULL)
1849 strncpy(mlist->name, name, 64);
1850 else
1851 mlist->name[0]=0;
1852 if(pm==NULL)
1853 dbgprintf("ERROR::: CreateSemaphoreA failure\n");
1854 if(name)
1855 dbgprintf("CreateSemaphoreA(0x%x, init_count %d, max_count %d, name 0x%x='%s') => 0x%x\n",
1856 v1, init_count, max_count, name, name, mlist);
1857 else
1858 dbgprintf("CreateSemaphoreA(0x%x, init_count %d, max_count %d, name 0) => 0x%x\n",
1859 v1, init_count, max_count, mlist);
1860 return (HANDLE)mlist;
1861 }
1862
1863 static long WINAPI expReleaseSemaphore(long hsem, long increment, long* prev_count)
1864 {
1865 // The state of a semaphore object is signaled when its count
1866 // is greater than zero and nonsignaled when its count is equal to zero
1867 // Each time a waiting thread is released because of the semaphore's signaled
1868 // state, the count of the semaphore is decreased by one.
1869 mutex_list *ml = (mutex_list *)hsem;
1870
1871 pthread_mutex_lock(ml->pm);
1872 if (prev_count != 0) *prev_count = ml->semaphore;
1873 if (ml->semaphore == 0) pthread_cond_signal(ml->pc);
1874 ml->semaphore += increment;
1875 pthread_mutex_unlock(ml->pm);
1876 dbgprintf("ReleaseSemaphore(semaphore 0x%x, increment %d, prev_count 0x%x) => 1\n",
1877 hsem, increment, prev_count);
1878 return 1;
1879 }
1880
1881
1882 static long WINAPI expRegOpenKeyExA(long key, const char* subkey, long reserved, long access, int* newkey)
1883 {
1884 long result=RegOpenKeyExA(key, subkey, reserved, access, newkey);
1885 dbgprintf("RegOpenKeyExA(key 0x%x, subkey %s, reserved %d, access 0x%x, pnewkey 0x%x) => %d\n",
1886 key, subkey, reserved, access, newkey, result);
1887 if(newkey)dbgprintf(" New key: 0x%x\n", *newkey);
1888 return result;
1889 }
1890 static long WINAPI expRegCloseKey(long key)
1891 {
1892 long result=RegCloseKey(key);
1893 dbgprintf("RegCloseKey(0x%x) => %d\n", key, result);
1894 return result;
1895 }
1896 static long WINAPI expRegQueryValueExA(long key, const char* value, int* reserved, int* type, int* data, int* count)
1897 {
1898 long result=RegQueryValueExA(key, value, reserved, type, data, count);
1899 dbgprintf("RegQueryValueExA(key 0x%x, value %s, reserved 0x%x, data 0x%x, count 0x%x)"
1900 " => 0x%x\n", key, value, reserved, data, count, result);
1901 if(data && count)dbgprintf(" read %d bytes: '%s'\n", *count, data);
1902 return result;
1903 }
1904
1905 //from wine source dlls/advapi32/registry.c
1906 static long WINAPI expRegCreateKeyA(long hkey, const char* name, int *retkey)
1907 {
1908 dbgprintf("RegCreateKeyA(key 0x%x, name 0x%x='%s',newkey=0x%x)\n",hkey,name,retkey);
1909 return RegCreateKeyExA( hkey, name, 0, NULL,REG_OPTION_NON_VOLATILE,
1910 KEY_ALL_ACCESS , NULL, retkey, NULL );
1911 }
1912
1913 static long WINAPI expRegCreateKeyExA(long key, const char* name, long reserved,
1914 void* classs, long options, long security,
1915 void* sec_attr, int* newkey, int* status)
1916 {
1917 long result=RegCreateKeyExA(key, name, reserved, classs, options, security, sec_attr, newkey, status);
1918 dbgprintf("RegCreateKeyExA(key 0x%x, name 0x%x='%s', reserved=0x%x,"
1919 " 0x%x, 0x%x, 0x%x, newkey=0x%x, status=0x%x) => %d\n",
1920 key, name, name, reserved, classs, options, security, sec_attr, newkey, status, result);
1921 if(!result && newkey) dbgprintf(" New key: 0x%x\n", *newkey);
1922 if(!result && status) dbgprintf(" New key status: 0x%x\n", *status);
1923 return result;
1924 }
1925 static long WINAPI expRegSetValueExA(long key, const char* name, long v1, long v2, void* data, long size)
1926 {
1927 long result=RegSetValueExA(key, name, v1, v2, data, size);
1928 dbgprintf("RegSetValueExA(key 0x%x, name '%s', 0x%x, 0x%x, data 0x%x -> 0x%x '%s', size=%d) => %d",
1929 key, name, v1, v2, data, *(int*)data, data, size, result);
1930 return result;
1931 }
1932
1933 static long WINAPI expRegOpenKeyA (long hKey, LPCSTR lpSubKey, int* phkResult)
1934 {
1935 long result=RegOpenKeyExA(hKey, lpSubKey, 0, 0, phkResult);
1936 dbgprintf("RegOpenKeyExA(key 0x%x, subkey '%s', 0x%x) => %d\n",
1937 hKey, lpSubKey, phkResult, result);
1938 if(!result && phkResult) dbgprintf(" New key: 0x%x\n", *phkResult);
1939 return result;
1940 }
1941
1942 static DWORD WINAPI expRegEnumValueA(HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
1943 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count)
1944 {
1945 return RegEnumValueA(hkey, index, value, val_count,
1946 reserved, type, data, count);
1947 }
1948
1949 static DWORD WINAPI expRegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcbName,
1950 LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcbClass,
1951 LPFILETIME lpftLastWriteTime)
1952 {
1953 return RegEnumKeyExA(hKey, dwIndex, lpName, lpcbName, lpReserved, lpClass,
1954 lpcbClass, lpftLastWriteTime);
1955 }
1956
1957 static long WINAPI expQueryPerformanceCounter(long long* z)
1958 {
1959 longcount(z);
1960 dbgprintf("QueryPerformanceCounter(0x%x) => 1 ( %Ld )\n", z, *z);
1961 return 1;
1962 }
1963
1964 /*
1965 * dummy function RegQueryInfoKeyA(), required by vss codecs
1966 */
1967 static DWORD WINAPI expRegQueryInfoKeyA( HKEY hkey, LPSTR class, LPDWORD class_len, LPDWORD reserved,
1968 LPDWORD subkeys, LPDWORD max_subkey, LPDWORD max_class,
1969 LPDWORD values, LPDWORD max_value, LPDWORD max_data,
1970 LPDWORD security, FILETIME *modif )
1971 {
1972 return ERROR_SUCCESS;
1973 }
1974
1975 /*
1976 * return CPU clock (in kHz), using linux's /proc filesystem (/proc/cpuinfo)
1977 */
1978 static double linux_cpuinfo_freq()
1979 {
1980 double freq=-1;
1981 FILE *f;
1982 char line[200];
1983 char *s,*value;
1984
1985 f = fopen ("/proc/cpuinfo", "r");
1986 if (f != NULL) {
1987 while (fgets(line,sizeof(line),f)!=NULL) {
1988 /* NOTE: the ':' is the only character we can rely on */
1989 if (!(value = strchr(line,':')))
1990 continue;
1991 /* terminate the valuename */
1992 *value++ = '\0';
1993 /* skip any leading spaces */
1994 while (*value==' ') value++;
1995 if ((s=strchr(value,'\n')))
1996 *s='\0';
1997
1998 if (!strncasecmp(line, "cpu MHz",strlen("cpu MHz"))
1999 && sscanf(value, "%lf", &freq) == 1) {
2000 freq*=1000;
2001 break;
2002 }
2003 }
2004 fclose(f);
2005 }
2006 return freq;
2007 }
2008
2009
2010 static double solaris_kstat_freq()
2011 {
2012 #if defined(HAVE_LIBKSTAT) && defined(KSTAT_DATA_INT32)
2013 /*
2014 * try to extract the CPU speed from the solaris kernel's kstat data
2015 */
2016 kstat_ctl_t *kc;
2017 kstat_t *ksp;
2018 kstat_named_t *kdata;
2019 int mhz = 0;
2020
2021 kc = kstat_open();
2022 if (kc != NULL)
2023 {
2024 ksp = kstat_lookup(kc, "cpu_info", 0, "cpu_info0");
2025
2026 /* kstat found and name/value pairs? */
2027 if (ksp != NULL && ksp->ks_type == KSTAT_TYPE_NAMED)
2028 {
2029 /* read the kstat data from the kernel */
2030 if (kstat_read(kc, ksp, NULL) != -1)
2031 {
2032 /*
2033 * lookup desired "clock_MHz" entry, check the expected
2034 * data type
2035 */
2036 kdata = (kstat_named_t *)kstat_data_lookup(ksp, "clock_MHz");
2037 if (kdata != NULL && kdata->data_type == KSTAT_DATA_INT32)
2038 mhz = kdata->value.i32;
2039 }
2040 }
2041 kstat_close(kc);
2042 }
2043
2044 if (mhz > 0)
2045 return mhz * 1000.;
2046 #endif /* HAVE_LIBKSTAT */
2047 return -1; // kstat stuff is not available, CPU freq is unknown
2048 }
2049
2050 /*
2051 * Measure CPU freq using the pentium's time stamp counter register (TSC)
2052 */
2053 static double tsc_freq()
2054 {
2055 static double ofreq=0.0;
2056 int i;
2057 int x,y;
2058 i=time(NULL);
2059 if (ofreq != 0.0) return ofreq;
2060 while(i==time(NULL));
2061 x=localcount();
2062 i++;
2063 while(i==time(NULL));
2064 y=localcount();
2065 ofreq = (double)(y-x)/1000.;
2066 return ofreq;
2067 }
2068
2069 static double CPU_Freq()
2070 {
2071 double freq;
2072
2073 if ((freq = linux_cpuinfo_freq()) > 0)
2074 return freq;
2075
2076 if ((freq = solaris_kstat_freq()) > 0)
2077 return freq;
2078
2079 return tsc_freq();
2080 }
2081
2082 static long WINAPI expQueryPerformanceFrequency(long long* z)
2083 {
2084 *z=(long long)CPU_Freq();
2085 dbgprintf("QueryPerformanceFrequency(0x%x) => 1 ( %Ld )\n", z, *z);
2086 return 1;
2087 }
2088 static long WINAPI exptimeGetTime()
2089 {
2090 struct timeval t;
2091 long result;
2092 gettimeofday(&t, 0);
2093 result=1000*t.tv_sec+t.tv_usec/1000;
2094 dbgprintf("timeGetTime() => %d\n", result);
2095 return result;
2096 }
2097 static void* WINAPI expLocalHandle(void* v)
2098 {
2099 dbgprintf("LocalHandle(0x%x) => 0x%x\n", v, v);
2100 return v;
2101 }
2102
2103 static void* WINAPI expGlobalHandle(void* v)
2104 {
2105 dbgprintf("GlobalHandle(0x%x) => 0x%x\n", v, v);
2106 return v;
2107 }
2108 static int WINAPI expGlobalUnlock(void* v)
2109 {
2110 dbgprintf("GlobalUnlock(0x%x) => 1\n", v);
2111 return 1;
2112 }
2113 static void* WINAPI expGlobalFree(void* v)
2114 {
2115 dbgprintf("GlobalFree(0x%x) => 0\n", v);
2116 my_release(v);
2117 //free(v);
2118 return 0;
2119 }
2120
2121 static void* WINAPI expGlobalReAlloc(void* v, int size, int flags)
2122 {
2123 void* result=my_realloc(v, size);
2124 //void* result=realloc(v, size);
2125 dbgprintf("GlobalReAlloc(0x%x, size %d, flags 0x%x) => 0x%x\n", v,size,flags,result);
2126 return result;
2127 }
2128
2129 static int WINAPI expLocalUnlock(void* v)
2130 {
2131 dbgprintf("LocalUnlock(0x%x) => 1\n", v);
2132 return 1;
2133 }
2134 //
2135 static void* WINAPI expLocalFree(void* v)
2136 {
2137 dbgprintf("LocalFree(0x%x) => 0\n", v);
2138 my_release(v);
2139 return 0;
2140 }
2141 static HRSRC WINAPI expFindResourceA(HMODULE module, char* name, char* type)
2142 {
2143 HRSRC result;
2144
2145 result=FindResourceA(module, name, type);
2146 dbgprintf("FindResourceA(module 0x%x, name 0x%x(%s), type 0x%x(%s)) => 0x%x\n",
2147 module, name, HIWORD(name) ? name : "UNICODE", type, HIWORD(type) ? type : "UNICODE", result);
2148 return result;
2149 }
2150
2151 extern HRSRC WINAPI LoadResource(HMODULE, HRSRC);
2152 static HGLOBAL WINAPI expLoadResource(HMODULE module, HRSRC res)
2153 {
2154 HGLOBAL result=LoadResource(module, res);
2155 dbgprintf("LoadResource(module 0x%x, resource 0x%x) => 0x%x\n", module, res, result);
2156 return result;
2157 }
2158 static void* WINAPI expLockResource(long res)
2159 {
2160 void* result=LockResource(res);
2161 dbgprintf("LockResource(0x%x) => 0x%x\n", res, result);
2162 return result;
2163 }
2164 static int WINAPI expFreeResource(long res)
2165 {
2166 int result=FreeResource(res);
2167 dbgprintf("FreeResource(0x%x) => %d\n", res, result);
2168 return result;
2169 }
2170 //bool fun(HANDLE)
2171 //!0 on success
2172 static int WINAPI expCloseHandle(long v1)
2173 {
2174 dbgprintf("CloseHandle(0x%x) => 1\n", v1);
2175 /* do not close stdin,stdout and stderr */
2176 if (v1 > 2)
2177 if (!close(v1))
2178 return 0;
2179 return 1;
2180 }
2181
2182 static const char* WINAPI expGetCommandLineA()
2183 {
2184 dbgprintf("GetCommandLineA() => \"c:\\aviplay.exe\"\n");
2185 return "c:\\aviplay.exe";
2186 }
2187 static short envs[]={'p', 'a', 't', 'h', ' ', 'c', ':', '\\', 0, 0};
2188 static LPWSTR WINAPI expGetEnvironmentStringsW()
2189 {
2190 dbgprintf("GetEnvironmentStringsW() => 0\n", envs);
2191 return 0;
2192 }
2193 static void * WINAPI expRtlZeroMemory(void *p, size_t len)
2194 {
2195 void* result=memset(p,0,len);
2196 dbgprintf("RtlZeroMemory(0x%x, len %d) => 0x%x\n",p,len,result);
2197 return result;
2198 }
2199 static void * WINAPI expRtlMoveMemory(void *dst, void *src, size_t len)
2200 {
2201 void* result=memmove(dst,src,len);
2202 dbgprintf("RtlMoveMemory (dest 0x%x, src 0x%x, len %d) => 0x%x\n",dst,src,len,result);
2203 return result;
2204 }
2205
2206 static void * WINAPI expRtlFillMemory(void *p, int ch, size_t len)
2207 {
2208 void* result=memset(p,ch,len);
2209 dbgprintf("RtlFillMemory(0x%x, char 0x%x, len %d) => 0x%x\n",p,ch,len,result);
2210 return result;
2211 }
2212 static int WINAPI expFreeEnvironmentStringsW(short* strings)
2213 {
2214 dbgprintf("FreeEnvironmentStringsW(0x%x) => 1\n", strings);
2215 return 1;
2216 }
2217 static int WINAPI expFreeEnvironmentStringsA(char* strings)
2218 {
2219 dbgprintf("FreeEnvironmentStringsA(0x%x) => 1\n", strings);
2220 return 1;
2221 }
2222
2223 static const char ch_envs[]=
2224 "__MSVCRT_HEAP_SELECT=__GLOBAL_HEAP_SELECTED,1\r\n"
2225 "PATH=C:\\;C:\\windows\\;C:\\windows\\system\r\n";
2226 static LPCSTR WINAPI expGetEnvironmentStrings()
2227 {
2228 dbgprintf("GetEnvironmentStrings() => 0x%x\n", ch_envs);
2229 return (LPCSTR)ch_envs;
2230 // dbgprintf("GetEnvironmentStrings() => 0\n");
2231 // return 0;
2232 }
2233
2234 static int WINAPI expGetStartupInfoA(STARTUPINFOA *s)
2235 {
2236 int i;
2237 dbgprintf("GetStartupInfoA(0x%x) => 1\n");
2238 memset(s, 0, sizeof(*s));
2239 s->cb=sizeof(*s);
2240 // s->lpReserved="Reserved";
2241 // s->lpDesktop="Desktop";
2242 // s->lpTitle="Title";
2243 // s->dwX=s->dwY=0;
2244 // s->dwXSize=s->dwYSize=200;
2245 s->dwFlags=s->wShowWindow=1;
2246 // s->hStdInput=s->hStdOutput=s->hStdError=0x1234;
2247 dbgprintf(" cb=%d\n", s->cb);
2248 dbgprintf(" lpReserved='%s'\n", s->lpReserved);
2249 dbgprintf(" lpDesktop='%s'\n", s->lpDesktop);
2250 dbgprintf(" lpTitle='%s'\n", s->lpTitle);
2251 dbgprintf(" dwX=%d dwY=%d dwXSize=%d dwYSize=%d\n",
2252 s->dwX, s->dwY, s->dwXSize, s->dwYSize);
2253 dbgprintf(" dwXCountChars=%d dwYCountChars=%d dwFillAttribute=%d\n",
2254 s->dwXCountChars, s->dwYCountChars, s->dwFillAttribute);
2255 dbgprintf(" dwFlags=0x%x wShowWindow=0x%x cbReserved2=0x%x\n",
2256 s->dwFlags, s->wShowWindow, s->cbReserved2);
2257 dbgprintf(" lpReserved2=0x%x hStdInput=0x%x hStdOutput=0x%x hStdError=0x%x\n",
2258 s->lpReserved2, s->hStdInput, s->hStdOutput, s->hStdError);
2259 return 1;
2260 }
2261
2262 static int WINAPI expGetStdHandle(int z)
2263 {
2264 dbgprintf("GetStdHandle(0x%x) => 0x%x\n", z+0x1234);
2265 return z+0x1234;
2266 }
2267
2268 #ifdef QTX
2269 #define FILE_HANDLE_quicktimeqts ((HANDLE)0x444)
2270 #define FILE_HANDLE_quicktimeqtx ((HANDLE)0x445)
2271 #endif
2272
2273 static int WINAPI expGetFileType(int handle)
2274 {
2275 dbgprintf("GetFileType(0x%x) => 0x3 = pipe\n", handle);
2276 return 0x3;
2277 }
2278 #ifdef QTX
2279 static int WINAPI expGetFileAttributesA(char *filename)
2280 {
2281 dbgprintf("GetFileAttributesA(%s) => FILE_ATTR_NORMAL\n", filename);
2282 if (strstr(filename, "QuickTime.qts"))
2283 return FILE_ATTRIBUTE_SYSTEM;
2284 return FILE_ATTRIBUTE_NORMAL;
2285 }
2286 #endif
2287 static int WINAPI expSetHandleCount(int count)
2288 {
2289 dbgprintf("SetHandleCount(0x%x) => 1\n", count);
2290 return 1;
2291 }
2292 static int WINAPI expGetACP(void)
2293 {
2294 dbgprintf("GetACP() => 0\n");
2295 return 0;
2296 }
2297 extern WINE_MODREF *MODULE32_LookupHMODULE(HMODULE m);
2298 static int WINAPI expGetModuleFileNameA(int module, char* s, int len)
2299 {
2300 WINE_MODREF *mr;
2301 int result;
2302 //printf("File name of module %X (%s) requested\n", module, s);
2303
2304 if (module == 0 && len >= 12)
2305 {
2306 /* return caller program name */
2307 strcpy(s, "aviplay.dll");
2308 result=1;
2309 }
2310 else if(s==0)
2311 result=0;
2312 else
2313 if(len<35)
2314 result=0;
2315 else
2316 {
2317 result=1;
2318 strcpy(s, "c:\\windows\\system\\");
2319 mr=MODULE32_LookupHMODULE(module);
2320 if(mr==0)//oops
2321 strcat(s, "aviplay.dll");
2322 else
2323 if(strrchr(mr->filename, '/')==NULL)
2324 strcat(s, mr->filename);
2325 else
2326 strcat(s, strrchr(mr->filename, '/')+1);
2327 }
2328 if(!s)
2329 dbgprintf("GetModuleFileNameA(0x%x, 0x%x, %d) => %d\n",
2330 module, s, len, result);
2331 else
2332 dbgprintf("GetModuleFileNameA(0x%x, 0x%x, %d) => %d ( '%s' )\n",
2333 module, s, len, result, s);
2334 return result;
2335 }
2336
2337 static int WINAPI expSetUnhandledExceptionFilter(void* filter)
2338 {
2339 dbgprintf("SetUnhandledExceptionFilter(0x%x) => 1\n", filter);
2340 return 1;//unsupported and probably won't ever be supported
2341 }
2342
2343 static int WINAPI expLoadLibraryA(char* name)
2344 {
2345 int result = 0;
2346 char* lastbc;
2347 int i;
2348 if (!name)
2349 return -1;
2350 // we skip to the last backslash
2351 // this is effectively eliminating weird characters in
2352 // the text output windows
2353
2354 lastbc = strrchr(name, '\\');
2355 if (lastbc)
2356 {
2357 int i;
2358 lastbc++;
2359 for (i = 0; 1 ;i++)
2360 {
2361 name[i] = *lastbc++;
2362 if (!name[i])
2363 break;
2364 }
2365 }
2366 if(strncmp(name, "c:\\windows\\", 11)==0) name += 11;
2367 if(strncmp(name, ".\\", 2)==0) name += 2;
2368
2369 dbgprintf("Entering LoadLibraryA(%s)\n", name);
2370
2371 // PIMJ and VIVO audio are loading kernel32.dll
2372 if (strcasecmp(name, "kernel32.dll") == 0 || strcasecmp(name, "kernel32") == 0)
2373 return MODULE_HANDLE_kernel32;
2374 // return ERROR_SUCCESS; /* yeah, we have also the kernel32 calls */
2375 /* exported -> do not return failed! */
2376
2377 if (strcasecmp(name, "user32.dll") == 0 || strcasecmp(name, "user32") == 0)
2378 // return MODULE_HANDLE_kernel32;
2379 return MODULE_HANDLE_user32;
2380
2381 #ifdef QTX
2382 if (strcasecmp(name, "wininet.dll") == 0 || strcasecmp(name, "wininet") == 0)
2383 return MODULE_HANDLE_wininet;
2384 if (strcasecmp(name, "ddraw.dll") == 0 || strcasecmp(name, "ddraw") == 0)
2385 return MODULE_HANDLE_ddraw;
2386 if (strcasecmp(name, "advapi32.dll") == 0 || strcasecmp(name, "advapi32") == 0)
2387 return MODULE_HANDLE_advapi32;
2388 #endif
2389
2390 if (strcasecmp(name, "comdlg32.dll") == 0 || strcasecmp(name, "comdlg32") == 0)
2391 return MODULE_HANDLE_comdlg32;
2392 if (strcasecmp(name, "msvcrt.dll") == 0 || strcasecmp(name, "msvcrt") == 0)
2393 return MODULE_HANDLE_msvcrt;
2394 if (strcasecmp(name, "ole32.dll") == 0 || strcasecmp(name, "ole32") == 0)
2395 return MODULE_HANDLE_ole32;
2396 if (strcasecmp(name, "winmm.dll") == 0 || strcasecmp(name, "winmm") == 0)
2397 return MODULE_HANDLE_winmm;
2398
2399 result=LoadLibraryA(name);
2400 dbgprintf("Returned LoadLibraryA(0x%x='%s'), def_path=%s => 0x%x\n", name, name, def_path, result);
2401
2402 return result;
2403 }
2404
2405 static int WINAPI expFreeLibrary(int module)
2406 {
2407 #ifdef QTX
2408 int result=0; /* FIXME:XXX: qtx svq3 frees up qt.qts */
2409 #else
2410 int result=FreeLibrary(module);
2411 #endif
2412 dbgprintf("FreeLibrary(0x%x) => %d\n", module, result);
2413 return result;
2414 }
2415
2416 static void* WINAPI expGetProcAddress(HMODULE mod, char* name)
2417 {
2418 void* result;
2419 switch(mod){
2420 case MODULE_HANDLE_kernel32:
2421 result=LookupExternalByName("kernel32.dll", name); break;
2422 case MODULE_HANDLE_user32:
2423 result=LookupExternalByName("user32.dll", name); break;
2424 #ifdef QTX
2425 case MODULE_HANDLE_wininet:
2426 result=LookupExternalByName("wininet.dll", name); break;
2427 case MODULE_HANDLE_ddraw:
2428 result=LookupExternalByName("ddraw.dll", name); break;
2429 case MODULE_HANDLE_advapi32:
2430 result=LookupExternalByName("advapi32.dll", name); break;
2431 #endif
2432 case MODULE_HANDLE_comdlg32:
2433 result=LookupExternalByName("comdlg32.dll", name); break;
2434 case MODULE_HANDLE_msvcrt:
2435 result=LookupExternalByName("msvcrt.dll", name); break;
2436 case MODULE_HANDLE_ole32:
2437 result=LookupExternalByName("ole32.dll", name); break;
2438 case MODULE_HANDLE_winmm:
2439 result=LookupExternalByName("winmm.dll", name); break;
2440 default:
2441 result=GetProcAddress(mod, name);
2442 }
2443 dbgprintf("GetProcAddress(0x%x, '%s') => 0x%x\n", mod, name, result);
2444 return result;
2445 }
2446
2447 static long WINAPI expCreateFileMappingA(int hFile, void* lpAttr,
2448 long flProtect, long dwMaxHigh,
2449 long dwMaxLow, const char* name)
2450 {
2451 long result=CreateFileMappingA(hFile, lpAttr, flProtect, dwMaxHigh, dwMaxLow, name);
2452 if(!name)
2453 dbgprintf("CreateFileMappingA(file 0x%x, lpAttr 0x%x,"
2454 "flProtect 0x%x, dwMaxHigh 0x%x, dwMaxLow 0x%x, name 0) => %d\n",
2455 hFile, lpAttr, flProtect, dwMaxHigh, dwMaxLow, result);
2456 else
2457 dbgprintf("CreateFileMappingA(file 0x%x, lpAttr 0x%x,"
2458 "flProtect 0x%x, dwMaxHigh 0x%x, dwMaxLow 0x%x, name 0x%x='%s') => %d\n",
2459 hFile, lpAttr, flProtect, dwMaxHigh, dwMaxLow, name, name, result);
2460 return result;
2461 }
2462
2463 static long WINAPI expOpenFileMappingA(long hFile, long hz, const char* name)
2464 {
2465 long result=OpenFileMappingA(hFile, hz, name);
2466 if(!name)
2467 dbgprintf("OpenFileMappingA(0x%x, 0x%x, 0) => %d\n",
2468 hFile, hz, result);
2469 else
2470 dbgprintf("OpenFileMappingA(0x%x, 0x%x, 0x%x='%s') => %d\n",
2471 hFile, hz, name, name, result);
2472 return result;
2473 }
2474
2475 static void* WINAPI expMapViewOfFile(HANDLE file, DWORD mode, DWORD offHigh,
2476 DWORD offLow, DWORD size)
2477 {
2478 dbgprintf("MapViewOfFile(0x%x, 0x%x, 0x%x, 0x%x, size %d) => 0x%x\n",
2479 file,mode,offHigh,offLow,size,(char*)file+offLow);
2480 return (char*)file+offLow;
2481 }
2482
2483 static void* WINAPI expUnmapViewOfFile(void* view)
2484 {
2485 dbgprintf("UnmapViewOfFile(0x%x) => 0\n", view);
2486 return 0;
2487 }
2488
2489 static void* WINAPI expSleep(int time)
2490 {
2491 #if HAVE_NANOSLEEP
2492 /* solaris doesn't have thread safe usleep */
2493 struct timespec tsp;
2494 tsp.tv_sec = time / 1000000;
2495 tsp.tv_nsec = (time % 1000000) * 1000;
2496 nanosleep(&tsp, NULL);
2497 #else
2498 usleep(time);
2499 #endif
2500 dbgprintf("Sleep(%d) => 0\n", time);
2501 return 0;
2502 }
2503
2504 // why does IV32 codec want to call this? I don't know ...
2505 static int WINAPI expCreateCompatibleDC(int hdc)
2506 {
2507 int dc = 0;//0x81;
2508 //dbgprintf("CreateCompatibleDC(%d) => 0x81\n", hdc);
2509 dbgprintf("CreateCompatibleDC(%d) => %d\n", hdc, dc);
2510 return dc;
2511 }
2512
2513 static int WINAPI expGetDeviceCaps(int hdc, int unk)
2514 {
2515 dbgprintf("GetDeviceCaps(0x%x, %d) => 0\n", hdc, unk);
2516 #ifdef QTX
2517 #define BITSPIXEL 12
2518 #define PLANES 14
2519 if (unk == BITSPIXEL)
2520 return 24;
2521 if (unk == PLANES)
2522 return 1;
2523 #endif
2524 return 1;
2525 }
2526
2527 static WIN_BOOL WINAPI expDeleteDC(int hdc)
2528 {
2529 dbgprintf("DeleteDC(0x%x) => 0\n", hdc);
2530 if (hdc == 0x81)
2531 return 1;
2532 return 0;
2533 }
2534
2535 static WIN_BOOL WINAPI expDeleteObject(int hdc)
2536 {
2537 dbgprintf("DeleteObject(0x%x) => 1\n", hdc);
2538 /* FIXME - implement code here */
2539 return 1;
2540 }
2541
2542 /* btvvc32.drv wants this one */
2543 static void* WINAPI expGetWindowDC(int hdc)
2544 {
2545 dbgprintf("GetWindowDC(%d) => 0x0\n", hdc);
2546 return 0;
2547 }
2548
2549 #ifdef QTX
2550 static int WINAPI expGetWindowRect(HWND win, RECT *r)
2551 {
2552 dbgprintf("GetWindowRect(0x%x, 0x%x) => 1\n", win, r);
2553 /* (win == 0) => desktop */
2554 r->right = PSEUDO_SCREEN_WIDTH;
2555 r->left = 0;
2556 r->bottom = PSEUDO_SCREEN_HEIGHT;
2557 r->top = 0;
2558 return 1;
2559 }
2560
2561 static int WINAPI expMonitorFromWindow(HWND win, int flags)
2562 {
2563 dbgprintf("MonitorFromWindow(0x%x, 0x%x) => 0\n", win, flags);
2564 return 0;
2565 }
2566
2567 static int WINAPI expMonitorFromRect(RECT *r, int flags)
2568 {
2569 dbgprintf("MonitorFromRect(0x%x, 0x%x) => 0\n", r, flags);
2570 return 0;
2571 }
2572
2573 static int WINAPI expMonitorFromPoint(void *p, int flags)
2574 {
2575 dbgprintf("MonitorFromPoint(0x%x, 0x%x) => 0\n", p, flags);
2576 return 0;
2577 }
2578
2579 static int WINAPI expEnumDisplayMonitors(void *dc, RECT *r,
2580 int WINAPI (*callback_proc)(), void *callback_param)
2581 {
2582 dbgprintf("EnumDisplayMonitors(0x%x, 0x%x, 0x%x, 0x%x) => ?\n",
2583 dc, r, callback_proc, callback_param);
2584 return callback_proc(0, dc, r, callback_param);
2585 }
2586
2587 #if 0
2588 typedef struct tagMONITORINFO {
2589 DWORD cbSize;
2590 RECT rcMonitor;
2591 RECT rcWork;
2592 DWORD dwFlags;
2593 } MONITORINFO, *LPMONITORINFO;
2594 #endif
2595
2596 #define CCHDEVICENAME 8
2597 typedef struct tagMONITORINFOEX {
2598 DWORD cbSize;
2599 RECT rcMonitor;
2600 RECT rcWork;
2601 DWORD dwFlags;
2602 TCHAR szDevice[CCHDEVICENAME];
2603 } MONITORINFOEX, *LPMONITORINFOEX;
2604
2605 static int WINAPI expGetMonitorInfoA(void *mon, LPMONITORINFO lpmi)
2606 {
2607 dbgprintf("GetMonitorInfoA(0x%x, 0x%x) => 1\n", mon, lpmi);
2608
2609 lpmi->rcMonitor.right = lpmi->rcWork.right = PSEUDO_SCREEN_WIDTH;
2610 lpmi->rcMonitor.left = lpmi->rcWork.left = 0;
2611 lpmi->rcMonitor.bottom = lpmi->rcWork.bottom = PSEUDO_SCREEN_HEIGHT;
2612 lpmi->rcMonitor.top = lpmi->rcWork.top = 0;
2613
2614 lpmi->dwFlags = 1; /* primary monitor */
2615
2616 if (lpmi->cbSize == sizeof(MONITORINFOEX))
2617 {
2618 LPMONITORINFOEX lpmiex = (LPMONITORINFOEX)lpmi;
2619 dbgprintf("MONITORINFOEX!\n");
2620 strncpy(lpmiex->szDevice, "Monitor1", CCHDEVICENAME);
2621 }
2622
2623 return 1;
2624 }
2625
2626 static int WINAPI expEnumDisplayDevicesA(const char *device, int devnum,
2627 void *dispdev, int flags)
2628 {
2629 dbgprintf("EnumDisplayDevicesA(0x%x = %s, %d, 0x%x, %x) => 1\n",
2630 device, device, devnum, dispdev, flags);
2631 return 1;
2632 }
2633
2634 static int WINAPI expIsWindowVisible(HWND win)
2635 {
2636 dbgprintf("IsWindowVisible(0x%x) => 1\n", win);
2637 return 1;
2638 }
2639
2640 static HWND WINAPI expGetActiveWindow(void)
2641 {
2642 dbgprintf("GetActiveWindow() => 0\n");
2643 return (HWND)0;
2644 }
2645
2646 static int WINAPI expGetClassNameA(HWND win, LPTSTR classname, int maxcount)
2647 {
2648 strncat(classname, "QuickTime", maxcount);
2649 dbgprintf("GetClassNameA(0x%x, 0x%x, %d) => %d\n",
2650 win, classname, maxcount, strlen(classname));
2651 return strlen(classname);
2652 }
2653
2654 #define LPWNDCLASS void *
2655 static int WINAPI expGetClassInfoA(HINSTANCE inst, LPCSTR classname, LPWNDCLASS wndclass)
2656 {
2657 dbgprintf("GetClassInfoA(0x%x, 0x%x = %s, 0x%x) => 1\n", inst,
2658 classname, classname, wndclass);
2659 return 1;
2660 }
2661
2662 static int WINAPI expGetWindowLongA(HWND win, int index)
2663 {
2664 dbgprintf("GetWindowLongA(0x%x, %d) => 0\n", win, index);
2665 return 1;
2666 }
2667
2668 static int WINAPI expGetObjectA(HGDIOBJ hobj, int objsize, LPVOID obj)
2669 {
2670 dbgprintf("GetObjectA(0x%x, %d, 0x%x) => %d\n", hobj, objsize, obj, objsize);
2671 return objsize;
2672 }
2673
2674 static int WINAPI expCreateRectRgn(int x, int y, int width, int height)
2675 {
2676 dbgprintf("CreateRectRgn(%d, %d, %d, %d) => 0\n", x, y, width, height);
2677 return 0;
2678 }
2679
2680 static int WINAPI expEnumWindows(int (*callback_func)(), void *callback_param)
2681 {
2682 int i, i2;
2683 dbgprintf("EnumWindows(0x%x, 0x%x) => 1\n", callback_func, callback_param);
2684 i = callback_func(0, callback_param);
2685 i2 = callback_func(1, callback_param);
2686 return i && i2;
2687 }
2688
2689 static int WINAPI expGetWindowThreadProcessId(HWND win, int *pid_data)
2690 {
2691 int tid = pthread_self();
2692 dbgprintf("GetWindowThreadProcessId(0x%x, 0x%x) => %d\n",
2693 win, pid_data, tid);
2694 if (pid_data)
2695 *(int*)pid_data = tid;
2696 return tid;
2697 }
2698
2699 //HWND WINAPI CreateWindowExA(DWORD,LPCSTR,LPCSTR,DWORD,INT,INT,
2700 // INT,INT,HWND,HMENU,HINSTANCE,LPVOID);
2701
2702 static HWND WINAPI expCreateWindowExA(int exstyle, const char *classname,
2703 const char *winname, int style, int x, int y, int w, int h,
2704 HWND parent, HMENU menu, HINSTANCE inst, LPVOID param)
2705 {
2706 printf("CreateWindowEx() called\n");
2707 dbgprintf("CreateWindowEx(%d, 0x%x = %s, 0x%x = %s, %d, %d, %d, %d, %d, 0x%x, 0x%x, 0x%x, 0x%x) => 1\n",
2708 exstyle, classname, classname, winname, winname, style, x, y, w, h,
2709 parent, menu, inst, param);
2710 printf("CreateWindowEx() called okey\n");
2711 return 1;
2712 }
2713
2714 static int WINAPI expwaveOutGetNumDevs(void)
2715 {
2716 dbgprintf("waveOutGetNumDevs() => 0\n");
2717 return 0;
2718 }
2719 #endif
2720
2721 /*
2722 * Returns the number of milliseconds, modulo 2^32, since the start
2723 * of the wineserver.
2724 */
2725 static int WINAPI expGetTickCount(void)
2726 {
2727 static int tcstart = 0;
2728 struct timeval t;
2729 int tc;
2730 gettimeofday( &t, NULL );
2731 tc = ((t.tv_sec * 1000) + (t.tv_usec / 1000)) - tcstart;
2732 if (tcstart == 0)
2733 {
2734 tcstart = 0;
2735 tc = 0;
2736 }
2737 dbgprintf("GetTickCount() => %d\n", tc);
2738 return tc;
2739 }
2740
2741 static int WINAPI expCreateFontA(void)
2742 {
2743 dbgprintf("CreateFontA() => 0x0\n");
2744 return 1;
2745 }
2746
2747 /* tried to get pvmjpg work in a different way - no success */
2748 static int WINAPI expDrawTextA(int hDC, char* lpString, int nCount,
2749 LPRECT lpRect, unsigned int uFormat)
2750 {
2751 dbgprintf("expDrawTextA(%p,...) => 8\n", hDC);
2752 return 8;
2753 }
2754
2755 static int WINAPI expGetPrivateProfileIntA(const char* appname,
2756 const char* keyname,
2757 int default_value,
2758 const char* filename)
2759 {
2760 int size=255;
2761 char buffer[256];
2762 char* fullname;
2763 int result;
2764
2765 buffer[255]=0;
2766 if(!(appname && keyname && filename) )
2767 {
2768 dbgprintf("GetPrivateProfileIntA('%s', '%s', %d, '%s') => %d\n", appname, keyname, default_value, filename, default_value );
2769 return default_value;
2770 }
2771 fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
2772 strcpy(fullname, "Software\\IniFileMapping\\");
2773 strcat(fullname, appname);
2774 strcat(fullname, "\\");
2775 strcat(fullname, keyname);
2776 strcat(fullname, "\\");
2777 strcat(fullname, filename);
2778 result=RegQueryValueExA(HKEY_LOCAL_MACHINE, fullname, NULL, NULL, (int*)buffer, &size);
2779 if((size>=0)&&(size<256))
2780 buffer[size]=0;
2781 // printf("GetPrivateProfileIntA(%s, %s, %s) -> %s\n", appname, keyname, filename, buffer);
2782 free(fullname);
2783 if(result)
2784 result=default_value;
2785 else
2786 result=atoi(buffer);
2787 dbgprintf("GetPrivateProfileIntA('%s', '%s', %d, '%s') => %d\n", appname, keyname, default_value, filename, result);
2788 return result;
2789 }
2790 static int WINAPI expGetProfileIntA(const char* appname,
2791 const char* keyname,
2792 int default_value)
2793 {
2794 dbgprintf("GetProfileIntA -> ");
2795 return expGetPrivateProfileIntA(appname, keyname, default_value, "default");
2796 }
2797
2798 static int WINAPI expGetPrivateProfileStringA(const char* appname,
2799 const char* keyname,
2800 const char* def_val,
2801 char* dest, unsigned int len,
2802 const char* filename)
2803 {
2804 int result;
2805 int size;
2806 char* fullname;
2807 dbgprintf("GetPrivateProfileStringA('%s', '%s', def_val '%s', 0x%x, 0x%x, '%s')", appname, keyname, def_val, dest, len, filename );
2808 if(!(appname && keyname && filename) ) return 0;
2809 fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
2810 strcpy(fullname, "Software\\IniFileMapping\\");
2811 strcat(fullname, appname);
2812 strcat(fullname, "\\");
2813 strcat(fullname, keyname);
2814 strcat(fullname, "\\");
2815 strcat(fullname, filename);
2816 size=len;
2817 result=RegQueryValueExA(HKEY_LOCAL_MACHINE, fullname, NULL, NULL, (int*)dest, &size);
2818 free(fullname);
2819 if(result)
2820 {
2821 strncpy(dest, def_val, size);
2822 if (strlen(def_val)< size) size = strlen(def_val);
2823 }
2824 dbgprintf(" => %d ( '%s' )\n", size, dest);
2825 return size;
2826 }
2827 static int WINAPI expWritePrivateProfileStringA(const char* appname,
2828 const char* keyname,
2829 const char* string,
2830 const char* filename)
2831 {
2832 int size=256;
2833 char* fullname;
2834 dbgprintf("WritePrivateProfileStringA('%s', '%s', '%s', '%s')", appname, keyname, string, filename );
2835 if(!(appname && keyname && filename) )
2836 {
2837 dbgprintf(" => -1\n");
2838 return -1;
2839 }
2840 fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
2841 strcpy(fullname, "Software\\IniFileMapping\\");
2842 strcat(fullname, appname);
2843 strcat(fullname, "\\");
2844 strcat(fullname, keyname);
2845 strcat(fullname, "\\");
2846 strcat(fullname, filename);
2847 RegSetValueExA(HKEY_LOCAL_MACHINE, fullname, 0, REG_SZ, (int*)string, strlen(string));
2848 // printf("RegSetValueExA(%s,%d)\n", string, strlen(string));
2849 // printf("WritePrivateProfileStringA(%s, %s, %s, %s)\n", appname, keyname, string, filename );
2850 free(fullname);
2851 dbgprintf(" => 0\n");
2852 return 0;
2853 }
2854
2855 unsigned int _GetPrivateProfileIntA(const char* appname, const char* keyname, INT default_value, const char* filename)
2856 {
2857 return expGetPrivateProfileIntA(appname, keyname, default_value, filename);
2858 }
2859 int _GetPrivateProfileStringA(const char* appname, const char* keyname,
2860 const char* def_val, char* dest, unsigned int len, const char* filename)
2861 {
2862 return expGetPrivateProfileStringA(appname, keyname, def_val, dest, len, filename);
2863 }
2864 int _WritePrivateProfileStringA(const char* appname, const char* keyname,
2865 const char* string, const char* filename)
2866 {
2867 return expWritePrivateProfileStringA(appname, keyname, string, filename);
2868 }
2869
2870
2871
2872 static int WINAPI expDefDriverProc(int _private, int id, int msg, int arg1, int arg2)
2873 {
2874 dbgprintf("DefDriverProc(0x%x, 0x%x, 0x%x, 0x%x, 0x%x) => 0\n", _private, id, msg, arg1, arg2);
2875 return 0;
2876 }
2877
2878 static int WINAPI expSizeofResource(int v1, int v2)
2879 {
2880 int result=SizeofResource(v1, v2);
2881 dbgprintf("SizeofResource(0x%x, 0x%x) => %d\n", v1, v2, result);
2882 return result;
2883 }
2884
2885 static int WINAPI expGetLastError()
2886 {
2887 int result=GetLastError();
2888 dbgprintf("GetLastError() => 0x%x\n", result);
2889 return result;
2890 }
2891
2892 static void WINAPI expSetLastError(int error)
2893 {
2894 dbgprintf("SetLastError(0x%x)\n", error);
2895 SetLastError(error);
2896 }
2897
2898 static int WINAPI expStringFromGUID2(GUID* guid, char* str, int cbMax)
2899 {
2900 int result=snprintf(str, cbMax, "%.8x-%.4x-%.4x-%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
2901 guid->f1, guid->f2, guid->f3,
2902 (unsigned char)guid->f4[0], (unsigned char)guid->f4[1],
2903 (unsigned char)guid->f4[2], (unsigned char)guid->f4[3],
2904 (unsigned char)guid->f4[4], (unsigned char)guid->f4[5],
2905 (unsigned char)guid->f4[6], (unsigned char)guid->f4[7]);
2906 dbgprintf("StringFromGUID2(0x%x, 0x%x='%s', %d) => %d\n", guid, str, str, cbMax, result);
2907 return result;
2908 }
2909
2910
2911 static int WINAPI expGetFileVersionInfoSizeA(const char* name, int* lpHandle)
2912 {
2913 dbgprintf("GetFileVersionInfoSizeA(0x%x='%s', 0x%X) => 0\n", name, name, lpHandle);
2914 return 0;
2915 }
2916
2917 static int WINAPI expIsBadStringPtrW(const short* string, int nchars)
2918 {
2919 int result;
2920 if(string==0)result=1; else result=0;
2921 dbgprintf("IsBadStringPtrW(0x%x, %d) => %d", string, nchars, result);
2922 if(string)wch_print(string);
2923 return result;
2924 }
2925 static int WINAPI expIsBadStringPtrA(const char* string, int nchars)
2926 {
2927 return expIsBadStringPtrW((const short*)string, nchars);
2928 }
2929 static long WINAPI expInterlockedExchangeAdd( long* dest, long incr )
2930 {
2931 long ret;
2932 __asm__ __volatile__
2933 (
2934 "lock; xaddl %0,(%1)"
2935 : "=r" (ret)
2936 : "r" (dest), "0" (incr)
2937 : "memory"
2938 );
2939 return ret;
2940 }
2941
2942 static long WINAPI expInterlockedCompareExchange( unsigned long* dest, unsigned long exchange, unsigned long comperand)
2943 {
2944 unsigned long retval = *dest;
2945 if(*dest == comperand)
2946 *dest = exchange;
2947 return retval;
2948 }
2949
2950 static long WINAPI expInterlockedIncrement( long* dest )
2951 {
2952 long result=expInterlockedExchangeAdd( dest, 1 ) + 1;
2953 dbgprintf("InterlockedIncrement(0x%x => %d) => %d\n", dest, *dest, result);
2954 return result;
2955 }
2956 static long WINAPI expInterlockedDecrement( long* dest )
2957 {
2958 long result=expInterlockedExchangeAdd( dest, -1 ) - 1;
2959 dbgprintf("InterlockedDecrement(0x%x => %d) => %d\n", dest, *dest, result);
2960 return result;
2961 }
2962
2963 static void WINAPI expOutputDebugStringA( const char* string )
2964 {
2965 dbgprintf("OutputDebugStringA(0x%x='%s')\n", string);
2966 fprintf(stderr, "DEBUG: %s\n", string);
2967 }
2968
2969 static int WINAPI expGetDC(int hwnd)
2970 {
2971 dbgprintf("GetDC(0x%x) => 1\n", hwnd);
2972 return 1;
2973 }
2974
2975 static int WINAPI expReleaseDC(int hwnd, int hdc)
2976 {
2977 dbgprintf("ReleaseDC(0x%x, 0x%x) => 1\n", hwnd, hdc);
2978 return 1;
2979 }
2980
2981 static int WINAPI expGetDesktopWindow()
2982 {
2983 dbgprintf("GetDesktopWindow() => 0\n");
2984 return 0;
2985 }
2986
2987 static int cursor[100];
2988
2989 static int WINAPI expLoadCursorA(int handle,LPCSTR name)
2990 {
2991 dbgprintf("LoadCursorA(%d, 0x%x='%s') => 0x%x\n", handle, name, (int)&cursor[0]);
2992 return (int)&cursor[0];
2993 }
2994 static int WINAPI expSetCursor(void *cursor)
2995 {
2996 dbgprintf("SetCursor(0x%x) => 0x%x\n", cursor, cursor);
2997 return (int)cursor;
2998 }
2999 static int WINAPI expGetCursorPos(void *cursor)
3000 {
3001 dbgprintf("GetCursorPos(0x%x) => 0x%x\n", cursor, cursor);
3002 return 1;
3003 }
3004 #ifdef QTX
3005 static int show_cursor = 0;
3006 static int WINAPI expShowCursor(int show)
3007 {
3008 dbgprintf("ShowCursor(%d) => %d\n", show, show);
3009 if (show)
3010 show_cursor++;
3011 else
3012 show_cursor--;
3013 return show_cursor;
3014 }
3015 #endif
3016 static int WINAPI expRegisterWindowMessageA(char *message)
3017 {
3018 dbgprintf("RegisterWindowMessageA(%s)\n", message);
3019 return 1;
3020 }
3021 static int WINAPI expGetProcessVersion(int pid)
3022 {
3023 dbgprintf("GetProcessVersion(%d)\n", pid);
3024 return 1;
3025 }
3026 static int WINAPI expGetCurrentThread(void)
3027 {
3028 #warning FIXME!
3029 dbgprintf("GetCurrentThread() => %x\n", 0xcfcf9898);
3030 return 0xcfcf9898;
3031 }
3032 static int WINAPI expGetOEMCP(void)
3033 {
3034 dbgprintf("GetOEMCP()\n");
3035 return 1;
3036 }
3037 static int WINAPI expGetCPInfo(int cp,void *info)
3038 {
3039 dbgprintf("GetCPInfo()\n");
3040 return 0;
3041 }
3042 #ifdef QTX
3043 #define SM_CXSCREEN 0
3044 #define SM_CYSCREEN 1
3045 #define SM_XVIRTUALSCREEN 76
3046 #define SM_YVIRTUALSCREEN 77
3047 #define SM_CXVIRTUALSCREEN 78
3048 #define SM_CYVIRTUALSCREEN 79
3049 #define SM_CMONITORS 80
3050 #endif
3051 static int WINAPI expGetSystemMetrics(int index)
3052 {
3053 dbgprintf("GetSystemMetrics(%d)\n", index);
3054 #ifdef QTX
3055 switch(index)
3056 {
3057 case SM_XVIRTUALSCREEN:
3058 case SM_YVIRTUALSCREEN:
3059 return 0;
3060 case SM_CXSCREEN:
3061 case SM_CXVIRTUALSCREEN:
3062 return PSEUDO_SCREEN_WIDTH;
3063 case SM_CYSCREEN:
3064 case SM_CYVIRTUALSCREEN:
3065 return PSEUDO_SCREEN_HEIGHT;
3066 case SM_CMONITORS:
3067 return 1;
3068 }
3069 #endif
3070 return 1;
3071 }
3072 static int WINAPI expGetSysColor(int index)
3073 {
3074 dbgprintf("GetSysColor(%d) => 1\n", index);
3075 return 1;
3076 }
3077 static int WINAPI expGetSysColorBrush(int index)
3078 {
3079 dbgprintf("GetSysColorBrush(%d)\n", index);
3080 return 1;
3081 }
3082
3083
3084
3085 static int WINAPI expGetSystemPaletteEntries(int hdc, int iStartIndex, int nEntries, void* lppe)
3086 {
3087 dbgprintf("GetSystemPaletteEntries(0x%x, 0x%x, 0x%x, 0x%x) => 0\n",
3088 hdc, iStartIndex, nEntries, lppe);
3089 return 0;
3090 }
3091
3092 /*
3093 typedef struct _TIME_ZONE_INFORMATION {
3094 long Bias;
3095 char StandardName[32];
3096 SYSTEMTIME StandardDate;
3097 long StandardBias;
3098 char DaylightName[32];
3099 SYSTEMTIME DaylightDate;
3100 long DaylightBias;
3101 } TIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;
3102 */
3103
3104 static int WINAPI expGetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation)
3105 {
3106 const short name[]={'C', 'e', 'n', 't', 'r', 'a', 'l', ' ', 'S', 't', 'a',
3107 'n', 'd', 'a', 'r', 'd', ' ', 'T', 'i', 'm', 'e', 0};
3108 const short pname[]={'C', 'e', 'n', 't', 'r', 'a', 'l', ' ', 'D', 'a', 'y',
3109 'l', 'i', 'g', 'h', 't', ' ', 'T', 'i', 'm', 'e', 0};
3110 dbgprintf("GetTimeZoneInformation(0x%x) => TIME_ZONE_ID_STANDARD\n");
3111 memset(lpTimeZoneInformation, 0, sizeof(TIME_ZONE_INFORMATION));
3112 lpTimeZoneInformation->Bias=360;//GMT-6
3113 memcpy(lpTimeZoneInformation->StandardName, name, sizeof(name));
3114 lpTimeZoneInformation->StandardDate.wMonth=10;
3115 lpTimeZoneInformation->StandardDate.wDay=5;
3116 lpTimeZoneInformation->StandardDate.wHour=2;
3117 lpTimeZoneInformation->StandardBias=0;
3118 memcpy(lpTimeZoneInformation->DaylightName, pname, sizeof(pname));
3119 lpTimeZoneInformation->DaylightDate.wMonth=4;
3120 lpTimeZoneInformation->DaylightDate.wDay=1;
3121 lpTimeZoneInformation->DaylightDate.wHour=2;
3122 lpTimeZoneInformation->DaylightBias=-60;
3123 return TIME_ZONE_ID_STANDARD;
3124 }
3125
3126 static void WINAPI expGetLocalTime(SYSTEMTIME* systime)
3127 {
3128 time_t local_time;
3129 struct tm *local_tm;
3130 struct timeval tv;
3131
3132 dbgprintf("GetLocalTime(0x%x)\n");
3133 gettimeofday(&tv, NULL);
3134 local_time=tv.tv_sec;
3135 local_tm=localtime(&local_time);
3136
3137 systime->wYear = local_tm->tm_year + 1900;
3138 systime->wMonth = local_tm->tm_mon + 1;
3139 systime->wDayOfWeek = local_tm->tm_wday;
3140 systime->wDay = local_tm->tm_mday;
3141 systime->wHour = local_tm->tm_hour;
3142 systime->wMinute = local_tm->tm_min;
3143 systime->wSecond = local_tm->tm_sec;
3144 systime->wMilliseconds = (tv.tv_usec / 1000) % 1000;
3145 dbgprintf(" Year: %d\n Month: %d\n Day of week: %d\n"
3146 " Day: %d\n Hour: %d\n Minute: %d\n Second: %d\n"
3147 " Milliseconds: %d\n",
3148 systime->wYear, systime->wMonth, systime->wDayOfWeek, systime->wDay,
3149 systime->wHour, systime->wMinute, systime->wSecond, systime->wMilliseconds);
3150 }
3151
3152 static int WINAPI expGetSystemTime(SYSTEMTIME* systime)
3153 {
3154 time_t local_time;
3155 struct tm *local_tm;
3156 struct timeval tv;
3157
3158 dbgprintf("GetSystemTime(0x%x)\n", systime);
3159 gettimeofday(&tv, NULL);
3160 local_time=tv.tv_sec;
3161 local_tm=gmtime(&local_time);
3162
3163 systime->wYear = local_tm->tm_year + 1900;
3164 systime->wMonth = local_tm->tm_mon + 1;
3165 systime->wDayOfWeek = local_tm->tm_wday;
3166 systime->wDay = local_tm->tm_mday;
3167 systime->wHour = local_tm->tm_hour;
3168 systime->wMinute = local_tm->tm_min;
3169 systime->wSecond = local_tm->tm_sec;
3170 systime->wMilliseconds = (tv.tv_usec / 1000) % 1000;
3171 dbgprintf(" Year: %d\n Month: %d\n Day of week: %d\n"
3172 " Day: %d\n Hour: %d\n Minute: %d\n Second: %d\n"
3173 " Milliseconds: %d\n",
3174 systime->wYear, systime->wMonth, systime->wDayOfWeek, systime->wDay,
3175 systime->wHour, systime->wMinute, systime->wSecond, systime->wMilliseconds);
3176 return 0;
3177 }
3178
3179 #define SECS_1601_TO_1970 ((369 * 365 + 89) * 86400ULL)
3180 static void WINAPI expGetSystemTimeAsFileTime(FILETIME* systime)
3181 {
3182 struct tm *local_tm;
3183 struct timeval tv;
3184 unsigned long long secs;
3185
3186 dbgprintf("GetSystemTime(0x%x)\n", systime);
3187 gettimeofday(&tv, NULL);
3188 secs = (tv.tv_sec + SECS_1601_TO_1970) * 10000000;
3189 secs += tv.tv_usec * 10;
3190 systime->dwLowDateTime = secs & 0xffffffff;
3191 systime->dwHighDateTime = (secs >> 32);
3192 }
3193
3194 static int WINAPI expGetEnvironmentVariableA(const char* name, char* field, int size)
3195 {
3196 char *p;
3197 // printf("%s %x %x\n", name, field, size);
3198 if(field)field[0]=0;
3199 /*
3200 p = getenv(name);
3201 if (p) strncpy(field,p,size);
3202 */
3203 if (strcmp(name,"__MSVCRT_HEAP_SELECT")==0)
3204 strcpy(field,"__GLOBAL_HEAP_SELECTED,1");
3205 dbgprintf("GetEnvironmentVariableA(0x%x='%s', 0x%x, %d) => %d\n", name, name, field, size, strlen(field));
3206 return strlen(field);
3207 }
3208
3209 static int WINAPI expSetEnvironmentVariableA(const char *name, const char *value)
3210 {
3211 dbgprintf("SetEnvironmentVariableA(%s, %s)\n", name, value);
3212 return 0;
3213 }
3214
3215 static void* WINAPI expCoTaskMemAlloc(ULONG cb)
3216 {
3217 return my_mreq(cb, 0);
3218 }
3219 static void WINAPI expCoTaskMemFree(void* cb)
3220 {
3221 my_release(cb);
3222 }
3223
3224
3225
3226
3227 void* CoTaskMemAlloc(unsigned long cb)
3228 {
3229 return expCoTaskMemAlloc(cb);
3230 }
3231 void CoTaskMemFree(void* cb)
3232 {
3233 expCoTaskMemFree(cb);
3234 }
3235
3236 struct COM_OBJECT_INFO
3237 {
3238 GUID clsid;
3239 long (*GetClassObject) (GUID* clsid, const GUID* iid, void** ppv);
3240 };
3241
3242 static struct COM_OBJECT_INFO* com_object_table=0;
3243 static int com_object_size=0;
3244 int RegisterComClass(const GUID* clsid, GETCLASSOBJECT gcs)
3245 {
3246 if(!clsid || !gcs)
3247 return -1;
3248 com_object_table=realloc(com_object_table, sizeof(struct COM_OBJECT_INFO)*(++com_object_size));
3249 com_object_table[com_object_size-1].clsid=*clsid;
3250 com_object_table[com_object_size-1].GetClassObject=gcs;
3251 return 0;
3252 }
3253
3254 int UnregisterComClass(const GUID* clsid, GETCLASSOBJECT gcs)
3255 {
3256 int found = 0;
3257 int i = 0;
3258 if(!clsid || !gcs)
3259 return -1;
3260
3261 if (com_object_table == 0)
3262 printf("Warning: UnregisterComClass() called without any registered class\n");
3263 while (i < com_object_size)
3264 {
3265 if (found && i > 0)
3266 {
3267 memcpy(&com_object_table[i - 1].clsid,
3268 &com_object_table[i].clsid, sizeof(GUID));
3269 com_object_table[i - 1].GetClassObject =
3270 com_object_table[i].GetClassObject;
3271 }
3272 else if (memcmp(&com_object_table[i].clsid, clsid, sizeof(GUID)) == 0
3273 && com_object_table[i].GetClassObject == gcs)
3274 {
3275 found++;
3276 }
3277 i++;
3278 }
3279 if (found)
3280 {
3281 if (--com_object_size == 0)
3282 {
3283 free(com_object_table);
3284 com_object_table = 0;
3285 }
3286 }
3287 return 0;
3288 }
3289
3290
3291 const GUID IID_IUnknown =
3292 {
3293 0x00000000, 0x0000, 0x0000,
3294 {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}
3295 };
3296 const GUID IID_IClassFactory =
3297 {
3298 0x00000001, 0x0000, 0x0000,
3299 {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}
3300 };
3301
3302 static long WINAPI expCoCreateInstance(GUID* rclsid, struct IUnknown* pUnkOuter,
3303 long dwClsContext, const GUID* riid, void** ppv)
3304 {
3305 int i;
3306 struct COM_OBJECT_INFO* ci=0;
3307 for(i=0; i<com_object_size; i++)
3308 if(!memcmp(rclsid, &com_object_table[i].clsid, sizeof(GUID)))
3309 ci=&com_object_table[i];
3310 if(!ci)return REGDB_E_CLASSNOTREG;
3311 // in 'real' world we should mess with IClassFactory here
3312 i=ci->GetClassObject(rclsid, riid, ppv);
3313 return i;
3314 }
3315
3316 long CoCreateInstance(GUID* rclsid, struct IUnknown* pUnkOuter,
3317 long dwClsContext, const GUID* riid, void** ppv)
3318 {
3319 return expCoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv);
3320 }
3321
3322 static int WINAPI expIsRectEmpty(CONST RECT *lprc)
3323 {
3324 int r = 0;
3325 int w,h;
3326 //trapbug();
3327 if (lprc)
3328 {
3329 w = lprc->right - lprc->left;
3330 h = lprc->bottom - lprc->top;
3331 if (w <= 0 || h <= 0)
3332 r = 1;
3333 }
3334 else
3335 r = 1;
3336
3337 dbgprintf("IsRectEmpty(%p) => %s\n", lprc, (r) ? "TRUE" : "FALSE");
3338 //printf("Rect: left: %d, top: %d, right: %d, bottom: %d\n", lprc->left, lprc->top, lprc->right, lprc->bottom);
3339 // return 0; // wmv9?
3340 return r; // TM20
3341 }
3342
3343 static int _adjust_fdiv=0; //what's this? - used to adjust division
3344
3345
3346
3347
3348 static unsigned int WINAPI expGetTempPathA(unsigned int len, char* path)
3349 {
3350 dbgprintf("GetTempPathA(%d, 0x%x)", len, path);
3351 if(len<5)
3352 {
3353 dbgprintf(" => 0\n");
3354 return 0;
3355 }
3356 strcpy(path, "/tmp");
3357 dbgprintf(" => 5 ( '/tmp' )\n");
3358 return 5;
3359 }
3360 /*
3361 FYI:
3362 typedef struct
3363 {
3364 DWORD dwFileAttributes;
3365 FILETIME ftCreationTime;
3366 FILETIME ftLastAccessTime;
3367 FILETIME ftLastWriteTime;
3368 DWORD nFileSizeHigh;
3369 DWORD nFileSizeLow;
3370 DWORD dwReserved0;
3371 DWORD dwReserved1;
3372 CHAR cFileName[260];
3373 CHAR cAlternateFileName[14];
3374 } WIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
3375 */
3376
3377 static DIR* qtx_dir=NULL;
3378
3379 static WIN_BOOL WINAPI expFindNextFileA(HANDLE h,LPWIN32_FIND_DATAA lpfd)
3380 {
3381 #ifdef QTX
3382 dbgprintf("FindNextFileA(0x%x, 0x%x) => 0\n", h, lpfd);
3383 if(h==FILE_HANDLE_quicktimeqtx){
3384 struct dirent* d;
3385 if(!qtx_dir) return 0;
3386 while((d=readdir(qtx_dir))){
3387 char* x=strrchr(d->d_name,'.');
3388 if(!x) continue;
3389 if(strcmp(x,".qtx")) continue;
3390 strcpy(lpfd->cFileName,d->d_name);
3391 // sprintf(lpfd->cAlternateFileName,"%-8s.qtx",d->d_name);
3392 strcpy(lpfd->cAlternateFileName,"foobar.qtx");
3393 printf("### FindNext: %s\n",lpfd->cFileName);
3394 return 1;
3395 }
3396 closedir(qtx_dir); qtx_dir=NULL;
3397 return 0;
3398 }
3399 #endif
3400 return 0;
3401 }
3402
3403 static HANDLE WINAPI expFindFirstFileA(LPCSTR s, LPWIN32_FIND_DATAA lpfd)
3404 {
3405 dbgprintf("FindFirstFileA(0x%x='%s', 0x%x) => 0\n", s, s, lpfd);
3406 // printf("\n### FindFirstFileA('%s')...\n",s);
3407 #ifdef QTX
3408 if(strstr(s, "quicktime\\*.QTX")){
3409 dbgprintf("FindFirstFileA(0x%x='%s', 0x%x) => QTX\n", s, s, lpfd);
3410 printf("\n### Searching for QuickTime plugins (*.qtx) at %s...\n",def_path);
3411 qtx_dir=opendir(def_path);
3412 if(!qtx_dir) return (HANDLE)-1;
3413 memset(lpfd,0,sizeof(*lpfd));
3414 if(expFindNextFileA(FILE_HANDLE_quicktimeqtx,lpfd))
3415 return FILE_HANDLE_quicktimeqtx;
3416 printf("loader: Couldn't find the QuickTime plugins (.qtx files) at %s\n",def_path);
3417 return (HANDLE)-1;
3418 }
3419 #if 0
3420 if(strstr(s, "QuickTime.qts")){
3421 dbgprintf("FindFirstFileA(0x%x='%s', 0x%x) => QTS\n", s, s, lpfd);
3422 // if(!strcmp(s,"C:\\windows\\QuickTime.qts\\QuickTime.qts\\*.QTX"))
3423 // return (HANDLE)-1;
3424 strcpy(lpfd->cFileName, "QuickTime.qts");
3425 strcpy(lpfd->cAlternateFileName, "QuickT~1.qts");
3426 return FILE_HANDLE_quicktimeqts;
3427 }
3428 #endif
3429 #endif
3430 if(strstr(s, "*.vwp")){
3431 // hack for VoxWare codec plugins:
3432 strcpy(lpfd->cFileName, "msms001.vwp");
3433 strcpy(lpfd->cAlternateFileName, "msms001.vwp");
3434 return (HANDLE)0;
3435 }
3436 // return 'file not found'
3437 return (HANDLE)-1;
3438 }
3439
3440 static WIN_BOOL WINAPI expFindClose(HANDLE h)
3441 {
3442 dbgprintf("FindClose(0x%x) => 0\n", h);
3443 #ifdef QTX
3444 // if(h==FILE_HANDLE_quicktimeqtx && qtx_dir){
3445 // closedir(qtx_dir);
3446 // qtx_dir=NULL;
3447 // }
3448 #endif
3449 return 0;
3450 }
3451 static UINT WINAPI expSetErrorMode(UINT i)
3452 {
3453 dbgprintf("SetErrorMode(%d) => 0\n", i);
3454 return 0;
3455 }
3456 static UINT WINAPI expGetWindowsDirectoryA(LPSTR s,UINT c)
3457 {
3458 char windir[]="c:\\windows";
3459 int result;
3460 strncpy(s, windir, c);
3461 result=1+((c<strlen(windir))?c:strlen(windir));
3462 dbgprintf("GetWindowsDirectoryA(0x%x, %d) => %d\n", s, c, result);
3463 return result;
3464 }
3465 #ifdef QTX
3466 static UINT WINAPI expGetCurrentDirectoryA(UINT c, LPSTR s)
3467 {
3468 char curdir[]="c:\\";
3469 int result;
3470 strncpy(s, curdir, c);
3471 result=1+((c<strlen(curdir))?c:strlen(curdir));
3472 dbgprintf("GetCurrentDirectoryA(0x%x, %d) => %d\n", s, c, result);
3473 return result;
3474 }
3475
3476 static int WINAPI expSetCurrentDirectoryA(const char *pathname)
3477 {
3478 dbgprintf("SetCurrentDirectoryA(0x%x = %s) => 1\n", pathname, pathname);
3479 #if 0
3480 if (strrchr(pathname, '\\'))
3481 chdir(strcat(strrchr(pathname, '\\')+1, '/'));
3482 else
3483 chdir(pathname);
3484 #endif
3485 return 1;
3486 }
3487
3488 static int WINAPI expCreateDirectoryA(const char *pathname, void *sa)
3489 {
3490 dbgprintf("CreateDirectory(0x%x = %s, 0x%x) => 1\n",
3491 pathname, pathname, sa);
3492 #if 0
3493 p = strrchr(pathname, '\\')+1;
3494 strcpy(&buf[0], p); /* should be strncpy */
3495 if (!strlen(p))
3496 {
3497 buf[0] = '.';
3498 buf[1] = 0;
3499 }
3500 #if 0
3501 if (strrchr(pathname, '\\'))
3502 mkdir(strcat(strrchr(pathname, '\\')+1, '/'), 666);
3503 else
3504 mkdir(pathname, 666);
3505 #endif
3506 mkdir(&buf);
3507 #endif
3508 return 1;
3509 }
3510 #endif
3511 static WIN_BOOL WINAPI expDeleteFileA(LPCSTR s)
3512 {
3513 dbgprintf("DeleteFileA(0x%x='%s') => 0\n", s, s);
3514 return 0;
3515 }
3516 static WIN_BOOL WINAPI expFileTimeToLocalFileTime(const FILETIME* cpf, LPFILETIME pf)
3517 {
3518 dbgprintf("FileTimeToLocalFileTime(0x%x, 0x%x) => 0\n", cpf, pf);
3519 return 0;
3520 }
3521
3522 static UINT WINAPI expGetTempFileNameA(LPCSTR cs1,LPCSTR cs2,UINT i,LPSTR ps)
3523 {
3524 char mask[16]="/tmp/AP_XXXXXX";
3525 int result;
3526 dbgprintf("GetTempFileNameA(0x%x='%s', 0x%x='%s', %d, 0x%x)", cs1, cs1, cs2, cs2, i, ps);
3527 if(i && i<10)
3528 {
3529 dbgprintf(" => -1\n");
3530 return -1;
3531 }
3532 result=mkstemp(mask);
3533 sprintf(ps, "AP%d", result);
3534 dbgprintf(" => %d\n", strlen(ps));
3535 return strlen(ps);
3536 }
3537 //
3538 // This func might need proper implementation if we want AngelPotion codec.
3539 // They try to open APmpeg4v1.apl with it.
3540 // DLL will close opened file with CloseHandle().
3541 //
3542 static HANDLE WINAPI expCreateFileA(LPCSTR cs1,DWORD i1,DWORD i2,
3543 LPSECURITY_ATTRIBUTES p1, DWORD i3,DWORD i4,HANDLE i5)
3544 {
3545 dbgprintf("CreateFileA(0x%x='%s', %d, %d, 0x%x, %d, %d, 0x%x)\n", cs1, cs1, i1,
3546 i2, p1, i3, i4, i5);
3547 if((!cs1) || (strlen(cs1)<2))return -1;
3548
3549 #ifdef QTX
3550 if(strstr(cs1, "QuickTime.qts"))
3551 {
3552 int result;
3553 char* tmp=(char*)malloc(strlen(def_path)+50);
3554 strcpy(tmp, def_path);
3555 strcat(tmp, "/");
3556 strcat(tmp, "QuickTime.qts");
3557 result=open(tmp, O_RDONLY);
3558 free(tmp);
3559 return result;
3560 }
3561 if(strstr(cs1, ".qtx"))
3562 {
3563 int result;
3564 char* tmp=(char*)malloc(strlen(def_path)+250);
3565 char* x=strrchr(cs1,'\\');
3566 sprintf(tmp,"%s/%s",def_path,x?(x+1):cs1);
3567 // printf("### Open: %s -> %s\n",cs1,tmp);
3568 result=open(tmp, O_RDONLY);
3569 free(tmp);
3570 return result;
3571 }
3572 #endif
3573
3574 if(strncmp(cs1, "AP", 2) == 0)
3575 {
3576 int result;
3577 char* tmp=(char*)malloc(strlen(def_path)+50);
3578 strcpy(tmp, def_path);
3579 strcat(tmp, "/");
3580 strcat(tmp, "APmpg4v1.apl");
3581 result=open(tmp, O_RDONLY);
3582 free(tmp);
3583 return result;
3584 }
3585 if (strstr(cs1, "vp3"))
3586 {
3587 int r;
3588 int flg = 0;
3589 char* tmp=(char*)malloc(20 + strlen(cs1));
3590 strcpy(tmp, "/tmp/");
3591 strcat(tmp, cs1);
3592 r = 4;
3593 while (tmp[r])
3594 {
3595 if (tmp[r] == ':' || tmp[r] == '\\')
3596 tmp[r] = '_';
3597 r++;
3598 }
3599 if (GENERIC_READ & i1)
3600 flg |= O_RDONLY;
3601 else if (GENERIC_WRITE & i1)
3602 {
3603 flg |= O_WRONLY;
3604 printf("Warning: openning filename %s %d (flags; 0x%x) for write\n", tmp, r, flg);
3605 }
3606 r=open(tmp, flg);
3607 free(tmp);
3608 return r;
3609 }
3610
3611 // Needed by wnvplay1.dll
3612 if (strstr(cs1, "WINNOV.bmp"))
3613 {
3614 int r;
3615 r=open("/dev/null", 0);
3616 return r;
3617 }
3618
3619 #if 0
3620 /* we need this for some virtualdub filters */
3621 {
3622 int r;
3623 int flg = 0;
3624 if (GENERIC_READ & i1)
3625 flg |= O_RDONLY;
3626 else if (GENERIC_WRITE & i1)
3627 {
3628 flg |= O_WRONLY;
3629 printf("Warning: openning filename %s %d (flags; 0x%x) for write\n", cs1, r, flg);
3630 }
3631 r=open(cs1, flg);
3632 return r;
3633 }
3634 #endif
3635
3636 return atoi(cs1+2);
3637 }
3638 static UINT WINAPI expGetSystemDirectoryA(
3639 char* lpBuffer, // address of buffer for system directory
3640 UINT uSize // size of directory buffer
3641 ){
3642 dbgprintf("GetSystemDirectoryA(%p,%d)\n", lpBuffer,uSize);
3643 if(!lpBuffer) strcpy(lpBuffer,".");
3644 return 1;
3645 }
3646 /*
3647 static char sysdir[]=".";
3648 static LPCSTR WINAPI expGetSystemDirectoryA()
3649 {
3650 dbgprintf("GetSystemDirectoryA() => 0x%x='%s'\n", sysdir, sysdir);
3651 return sysdir;
3652 }
3653 */
3654 static DWORD WINAPI expGetFullPathNameA
3655 (
3656 LPCTSTR lpFileName,
3657 DWORD nBufferLength,
3658 LPTSTR lpBuffer,
3659 LPTSTR lpFilePart
3660 ){
3661 if(!lpFileName) return 0;
3662 dbgprintf("GetFullPathNameA('%s',%d,%p,%p)\n",lpFileName,nBufferLength,
3663 lpBuffer, lpFilePart);
3664 #if 0
3665 #ifdef QTX
3666 strcpy(lpFilePart, "Quick123.qts");
3667 #else
3668 strcpy(lpFilePart, lpFileName);
3669 #endif
3670 #else
3671 if (strrchr(lpFileName, '\\'))
3672 lpFilePart = strrchr(lpFileName, '\\');
3673 else
3674 lpFilePart = (LPTSTR)lpFileName;
3675 #endif
3676 strcpy(lpBuffer, lpFileName);
3677 // strncpy(lpBuffer, lpFileName, rindex(lpFileName, '\\')-lpFileName);
3678 return strlen(lpBuffer);
3679 }
3680
3681 static DWORD WINAPI expGetShortPathNameA
3682 (
3683 LPCSTR longpath,
3684 LPSTR shortpath,
3685 DWORD shortlen
3686 ){
3687 if(!longpath) return 0;
3688 dbgprintf("GetShortPathNameA('%s',%p,%d)\n",longpath,shortpath,shortlen);
3689 strcpy(shortpath,longpath);
3690 return strlen(shortpath);
3691 }
3692
3693 static WIN_BOOL WINAPI expReadFile(HANDLE h,LPVOID pv,DWORD size,LPDWORD rd,LPOVERLAPPED unused)
3694 {
3695 int result;
3696 dbgprintf("ReadFile(%d, 0x%x, %d -> 0x%x)\n", h, pv, size, rd);
3697 result=read(h, pv, size);
3698 if(rd)*rd=result;
3699 if(!result)return 0;
3700 return 1;
3701 }
3702
3703 static WIN_BOOL WINAPI expWriteFile(HANDLE h,LPCVOID pv,DWORD size,LPDWORD wr,LPOVERLAPPED unused)
3704 {
3705 int result;
3706 dbgprintf("WriteFile(%d, 0x%x, %d -> 0x%x)\n", h, pv, size, wr);
3707 if(h==1234)h=1;
3708 result=write(h, pv, size);
3709 if(wr)*wr=result;
3710 if(!result)return 0;
3711 return 1;
3712 }
3713 static DWORD WINAPI expSetFilePointer(HANDLE h, LONG val, LPLONG ext, DWORD whence)
3714 {
3715 int wh;
3716 dbgprintf("SetFilePointer(%d, 0x%x, 0x%x = %d, %d)\n", h, val, ext, *ext, whence);
3717 //why would DLL want temporary file with >2Gb size?
3718 switch(whence)
3719 {
3720 case FILE_BEGIN:
3721 wh=SEEK_SET;break;
3722 case FILE_END:
3723 wh=SEEK_END;break;
3724 case FILE_CURRENT:
3725 wh=SEEK_CUR;break;
3726 default:
3727 return -1;
3728 }
3729 #ifdef QTX
3730 if (val == 0 && ext != 0)
3731 val = val&(*ext);
3732 #endif
3733 return lseek(h, val, wh);
3734 }
3735
3736 static HDRVR WINAPI expOpenDriverA(LPCSTR szDriverName, LPCSTR szSectionName,
3737 LPARAM lParam2)
3738 {
3739 dbgprintf("OpenDriverA(0x%x='%s', 0x%x='%s', 0x%x) => -1\n", szDriverName, szDriverName, szSectionName, szSectionName, lParam2);
3740 return -1;
3741 }
3742 static HDRVR WINAPI expOpenDriver(LPCSTR szDriverName, LPCSTR szSectionName,
3743 LPARAM lParam2)
3744 {
3745 dbgprintf("OpenDriver(0x%x='%s', 0x%x='%s', 0x%x) => -1\n", szDriverName, szDriverName, szSectionName, szSectionName, lParam2);
3746 return -1;
3747 }
3748
3749
3750 static WIN_BOOL WINAPI expGetProcessAffinityMask(HANDLE hProcess,
3751 LPDWORD lpProcessAffinityMask,
3752 LPDWORD lpSystemAffinityMask)
3753 {
3754 dbgprintf("GetProcessAffinityMask(0x%x, 0x%x, 0x%x) => 1\n",
3755 hProcess, lpProcessAffinityMask, lpSystemAffinityMask);
3756 if(lpProcessAffinityMask)*lpProcessAffinityMask=1;
3757 if(lpSystemAffinityMask)*lpSystemAffinityMask=1;
3758 return 1;
3759 }
3760
3761 static int WINAPI expMulDiv(int nNumber, int nNumerator, int nDenominator)
3762 {
3763 static const long long max_int=0x7FFFFFFFLL;
3764 static const long long min_int=-0x80000000LL;
3765 long long tmp=(long long)nNumber*(long long)nNumerator;
3766 dbgprintf("expMulDiv %d * %d / %d\n", nNumber, nNumerator, nDenominator);
3767 if(!nDenominator)return 1;
3768 tmp/=nDenominator;
3769 if(tmp<min_int) return 1;
3770 if(tmp>max_int) return 1;
3771 return (int)tmp;
3772 }
3773
3774 static LONG WINAPI explstrcmpiA(const char* str1, const char* str2)
3775 {
3776 LONG result=strcasecmp(str1, str2);
3777 dbgprintf("strcmpi(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result);
3778 return result;
3779 }
3780
3781 static LONG WINAPI explstrlenA(const char* str1)
3782 {
3783 LONG result=strlen(str1);
3784 dbgprintf("strlen(0x%x='%.50s') => %d\n", str1, str1, result);
3785 return result;
3786 }
3787
3788 static LONG WINAPI explstrcpyA(char* str1, const char* str2)
3789 {
3790 int result= (int) strcpy(str1, str2);
3791 dbgprintf("strcpy(0x%.50x, 0x%.50x='%.50s') => %d\n", str1, str2, str2, result);
3792 return result;
3793 }
3794 static LONG WINAPI explstrcpynA(char* str1, const char* str2,int len)
3795 {
3796 int result;
3797 if (strlen(str2)>len)
3798 result = (int) strncpy(str1, str2,len);
3799 else
3800 result = (int) strcpy(str1,str2);
3801 dbgprintf("strncpy(0x%x, 0x%x='%s' len %d strlen %d) => %x\n", str1, str2, str2,len, strlen(str2),result);
3802 return result;
3803 }
3804 static LONG WINAPI explstrcatA(char* str1, const char* str2)
3805 {
3806 int result= (int) strcat(str1, str2);
3807 dbgprintf("strcat(0x%x, 0x%x='%s') => %d\n", str1, str2, str2, result);
3808 return result;
3809 }
3810
3811
3812 static LONG WINAPI expInterlockedExchange(long *dest, long l)
3813 {
3814 long retval = *dest;
3815 *dest = l;
3816 return retval;
3817 }
3818
3819 static void WINAPI expInitCommonControls(void)
3820 {
3821 dbgprintf("InitCommonControls called!\n");
3822 return;
3823 }
3824
3825 #ifdef QTX
3826 /* needed by QuickTime.qts */
3827 static HWND WINAPI expCreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy,
3828 HWND parent, INT id, HINSTANCE inst,
3829 HWND buddy, INT maxVal, INT minVal, INT curVal)
3830 {
3831 dbgprintf("CreateUpDownControl(...)\n");
3832 return 0;
3833 }
3834 #endif
3835
3836 /* alex: implement this call! needed for 3ivx */
3837 static HRESULT WINAPI expCoCreateFreeThreadedMarshaler(void *pUnkOuter, void **ppUnkInner)
3838 {
3839 dbgprintf("CoCreateFreeThreadedMarshaler(%p, %p) called!\n",
3840 pUnkOuter, ppUnkInner);
3841 // return 0;
3842 return ERROR_CALL_NOT_IMPLEMENTED;
3843 }
3844
3845
3846 static int WINAPI expDuplicateHandle(HANDLE hSourceProcessHandle, // handle to source process
3847 HANDLE hSourceHandle, // handle to duplicate
3848 HANDLE hTargetProcessHandle, // handle to target process
3849 HANDLE* lpTargetHandle, // duplicate handle
3850 DWORD dwDesiredAccess, // requested access
3851 int bInheritHandle, // handle inheritance option
3852 DWORD dwOptions // optional actions
3853 )
3854 {
3855 dbgprintf("DuplicateHandle(%p, %p, %p, %p, 0x%x, %d, %d) called\n",
3856 hSourceProcessHandle, hSourceHandle, hTargetProcessHandle,
3857 lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions);
3858 *lpTargetHandle = hSourceHandle;
3859 return 1;
3860 }
3861
3862 // required by PIM1 codec (used by win98 PCTV Studio capture sw)
3863 static HRESULT WINAPI expCoInitialize(
3864 LPVOID lpReserved /* [in] pointer to win32 malloc interface
3865 (obsolete, should be NULL) */
3866 )
3867 {
3868 /*
3869 * Just delegate to the newer method.
3870 */
3871 return 0; //CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
3872 }
3873
3874 static DWORD WINAPI expSetThreadAffinityMask
3875 (
3876 HANDLE hThread,
3877 DWORD dwThreadAffinityMask
3878 ){
3879 return 0;
3880 };
3881
3882 /*
3883 * no WINAPI functions - CDECL
3884 */
3885 static void* expmalloc(int size)
3886 {
3887 //printf("malloc");
3888 // return malloc(size);
3889 void* result=my_mreq(size,0);
3890 dbgprintf("malloc(0x%x) => 0x%x\n", size,result);
3891 if(result==0)
3892 printf("WARNING: malloc() failed\n");
3893 return result;
3894 }
3895 static void expfree(void* mem)
3896 {
3897 // return free(mem);
3898 dbgprintf("free(%p)\n", mem);
3899 my_release(mem);
3900 }
3901 /* needed by atrac3.acm */
3902 static void *expcalloc(int num, int size)
3903 {
3904 void* result=my_mreq(num*size,1);
3905 dbgprintf("calloc(%d,%d) => %p\n", num,size,result);
3906 if(result==0)
3907 printf("WARNING: calloc() failed\n");
3908 return result;
3909 }
3910 static void* expnew(int size)
3911 {
3912 // printf("NEW:: Call from address %08x\n STACK DUMP:\n", *(-1+(int*)&size));
3913 // printf("%08x %08x %08x %08x\n",
3914 // size, *(1+(int*)&size),
3915 // *(2+(int*)&size),*(3+(int*)&size));
3916 void* result;
3917 assert(size >= 0);
3918
3919 result=my_mreq(size,0);
3920 dbgprintf("new(%d) => %p\n", size, result);
3921 if (result==0)
3922 printf("WARNING: new() failed\n");
3923 return result;
3924
3925 }
3926 static int expdelete(void* memory)
3927 {
3928 dbgprintf("delete(%p)\n", memory);
3929 my_release(memory);
3930 return 0;
3931 }
3932
3933 /*
3934 * local definition - we need only the last two members at this point
3935 * otherwice we would have to introduce here GUIDs and some more types..
3936 */
3937 typedef struct __attribute__((__packed__))
3938 {
3939 char hay[0x3C];
3940 void* pbUnknown; //0x3C
3941 unsigned long cbFormat; //0x40
3942 char* pbFormat; //0x44
3943 } MY_MEDIA_TYPE;
3944 static HRESULT WINAPI expMoCopyMediaType(MY_MEDIA_TYPE* dest, const MY_MEDIA_TYPE* src)
3945 {
3946 if (!dest || !src)
3947 return E_POINTER;
3948 memcpy(dest, src, sizeof(MY_MEDIA_TYPE));
3949 if (dest->cbFormat)
3950 {
3951 dest->pbFormat = (char*) my_mreq(dest->cbFormat, 0);
3952 if (!dest->pbFormat)
3953 return E_OUTOFMEMORY;
3954 memcpy(dest->pbFormat, src->pbFormat, dest->cbFormat);
3955 }
3956 return S_OK;
3957 }
3958 static HRESULT WINAPI expMoInitMediaType(MY_MEDIA_TYPE* dest, DWORD cbFormat)
3959 {
3960 if (!dest)
3961 return E_POINTER;
3962
3963 dest->pbUnknown = NULL;
3964 dest->cbFormat = cbFormat;
3965 if (cbFormat)
3966 {
3967 dest->pbFormat = (char*) my_mreq(cbFormat, 0);
3968 if (!dest->pbFormat)
3969 return E_OUTOFMEMORY;
3970 }
3971 else
3972 {
3973 dest->pbFormat=NULL;
3974 }
3975 return S_OK;
3976 }
3977 static HRESULT WINAPI expMoCreateMediaType(MY_MEDIA_TYPE** dest, DWORD cbFormat)
3978 {
3979 if (!dest)
3980 return E_POINTER;
3981 *dest = my_mreq(sizeof(MY_MEDIA_TYPE), 0);
3982 return expMoInitMediaType(*dest, cbFormat);
3983 }
3984 static HRESULT WINAPI expMoDuplicateMediaType(MY_MEDIA_TYPE** dest, const void* src)
3985 {
3986 if (!dest)
3987 return E_POINTER;
3988 *dest = my_mreq(sizeof(MY_MEDIA_TYPE), 0);
3989 return expMoCopyMediaType(*dest, src);
3990 }
3991 static HRESULT WINAPI expMoFreeMediaType(MY_MEDIA_TYPE* dest)
3992 {
3993 if (!dest)
3994 return E_POINTER;
3995 if (dest->pbFormat)
3996 {
3997 my_release(dest->pbFormat);
3998 dest->pbFormat = 0;
3999 dest->cbFormat = 0;
4000 }
4001 return S_OK;
4002 }
4003 static HRESULT WINAPI expMoDeleteMediaType(MY_MEDIA_TYPE* dest)
4004 {
4005 if (!dest)
4006 return E_POINTER;
4007 expMoFreeMediaType(dest);
4008 my_release(dest);
4009 return S_OK;
4010 }
4011
4012 static int exp_snprintf( char *str, int size, const char *format, ... )
4013 {
4014 int x;
4015 va_list va;
4016 va_start(va, format);
4017 x=snprintf(str,size,format,va);
4018 dbgprintf("_snprintf( 0x%x, %d, %s, ... ) => %d\n",str,size,format,x);
4019 va_end(va);
4020 return x;
4021 }
4022
4023 #if 0
4024 static int exp_initterm(int v1, int v2)
4025 {
4026 dbgprintf("_initterm(0x%x, 0x%x) => 0\n", v1, v2);
4027 return 0;
4028 }
4029 #else
4030 /* merged from wine - 2002.04.21 */
4031 typedef void (*_INITTERMFUNC)();
4032 static int exp_initterm(_INITTERMFUNC *start, _INITTERMFUNC *end)
4033 {
4034 dbgprintf("_initterm(0x%x, 0x%x) %p\n", start, end, *start);
4035 while (start < end)
4036 {
4037 if (*start)
4038 {
4039 //printf("call _initfunc: from: %p %d\n", *start);
4040 // ok this trick with push/pop is necessary as otherwice
4041 // edi/esi registers are being trashed
4042 void* p = *start;
4043 __asm__ __volatile__
4044 (
4045 "pushl %%ebx \n\t"
4046 "pushl %%ecx \n\t"
4047 "pushl %%edx \n\t"
4048 "pushl %%edi \n\t"
4049 "pushl %%esi \n\t"
4050 "call *%%eax \n\t"
4051 "popl %%esi \n\t"
4052 "popl %%edi \n\t"
4053 "popl %%edx \n\t"
4054 "popl %%ecx \n\t"
4055 "popl %%ebx \n\t"
4056 :
4057 : "a"(p)
4058 : "memory"
4059 );
4060 //printf("done %p %d:%d\n", end);
4061 }
4062 start++;
4063 }
4064 return 0;
4065 }
4066 #endif
4067
4068 static void* exp__dllonexit()
4069 {
4070 // FIXME extract from WINE
4071 return NULL;
4072 }
4073
4074 static int expwsprintfA(char* string, const char* format, ...)
4075 {
4076 va_list va;
4077 int result;
4078 va_start(va, format);
4079 result = vsprintf(string, format, va);
4080 dbgprintf("wsprintfA(0x%x, '%s', ...) => %d\n", string, format, result);
4081 va_end(va);
4082 return result;
4083 }
4084
4085 static int expsprintf(char* str, const char* format, ...)
4086 {
4087 va_list args;
4088 int r;
4089 dbgprintf("sprintf(0x%x, %s)\n", str, format);
4090 va_start(args, format);
4091 r = vsprintf(str, format, args);
4092 va_end(args);
4093 return r;
4094 }
4095 static int expsscanf(const char* str, const char* format, ...)
4096 {
4097 va_list args;
4098 int r;
4099 dbgprintf("sscanf(%s, %s)\n", str, format);
4100 va_start(args, format);
4101 r = vsscanf(str, format, args);
4102 va_end(args);
4103 return r;
4104 }
4105 static void* expfopen(const char* path, const char* mode)
4106 {
4107 printf("fopen: \"%s\" mode:%s\n", path, mode);
4108 //return fopen(path, mode);
4109 return fdopen(0, mode); // everything on screen
4110 }
4111 static int expfprintf(void* stream, const char* format, ...)
4112 {
4113 va_list args;
4114 int r = 0;
4115 dbgprintf("fprintf(%p, %s, ...)\n", stream, format);
4116 #if 1
4117 va_start(args, format);
4118 r = vfprintf((FILE*) stream, format, args);
4119 va_end(args);
4120 #endif
4121 return r;
4122 }
4123
4124 static int expprintf(const char* format, ...)
4125 {
4126 va_list args;
4127 int r;
4128 dbgprintf("printf(%s, ...)\n", format);
4129 va_start(args, format);
4130 r = vprintf(format, args);
4131 va_end(args);
4132 return r;
4133 }
4134
4135 static char* expgetenv(const char* varname)
4136 {
4137 char* v = getenv(varname);
4138 dbgprintf("getenv(%s) => %s\n", varname, v);
4139 return v;
4140 }
4141
4142 static void* expwcscpy(WCHAR* dst, const WCHAR* src)
4143 {
4144 WCHAR* p = dst;
4145 while ((*p++ = *src++))
4146 ;
4147 return dst;
4148 }
4149
4150 static char* expstrrchr(char* string, int value)
4151 {
4152 char* result=strrchr(string, value);
4153 if(result)
4154 dbgprintf("strrchr(0x%x='%s', %d) => 0x%x='%s'", string, string, value, result, result);
4155 else
4156 dbgprintf("strrchr(0x%x='%s', %d) => 0", string, string, value);
4157 return result;
4158 }
4159
4160 static char* expstrchr(char* string, int value)
4161 {
4162 char* result=strchr(string, value);
4163 if(result)
4164 dbgprintf("strchr(0x%x='%s', %d) => 0x%x='%s'", string, string, value, result, result);
4165 else
4166 dbgprintf("strchr(0x%x='%s', %d) => 0", string, string, value);
4167 return result;
4168 }
4169 static int expstrlen(char* str)
4170 {
4171 int result=strlen(str);
4172 dbgprintf("strlen(0x%x='%s') => %d\n", str, str, result);
4173 return result;
4174 }
4175 static char* expstrcpy(char* str1, const char* str2)
4176 {
4177 char* result= strcpy(str1, str2);
4178 dbgprintf("strcpy(0x%x, 0x%x='%s') => %p\n", str1, str2, str2, result);
4179 return result;
4180 }
4181 static char* expstrncpy(char* str1, const char* str2, size_t count)
4182 {
4183 char* result= strncpy(str1, str2, count);
4184 dbgprintf("strncpy(0x%x, 0x%x='%s', %d) => %p\n", str1, str2, str2, count, result);
4185 return result;
4186 }
4187 static int expstrcmp(const char* str1, const char* str2)
4188 {
4189 int result=strcmp(str1, str2);
4190 dbgprintf("strcmp(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result);
4191 return result;
4192 }
4193 static int expstrncmp(const char* str1, const char* str2,int x)
4194 {
4195 int result=strncmp(str1, str2,x);
4196 dbgprintf("strcmp(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result);
4197 return result;
4198 }
4199 static char* expstrcat(char* str1, const char* str2)
4200 {
4201 char* result = strcat(str1, str2);
4202 dbgprintf("strcat(0x%x='%s', 0x%x='%s') => %p\n", str1, str1, str2, str2, result);
4203 return result;
4204 }
4205 static char* exp_strdup(const char* str1)
4206 {
4207 int l = strlen(str1);
4208 char* result = (char*) my_mreq(l + 1,0);
4209 if (result)
4210 strcpy(result, str1);
4211 dbgprintf("_strdup(0x%x='%s') => %p\n", str1, str1, result);
4212 return result;
4213 }
4214 static int expisalnum(int c)
4215 {
4216 int result= (int) isalnum(c);
4217 dbgprintf("isalnum(0x%x='%c' => %d\n", c, c, result);
4218 return result;
4219 }
4220 static int expisspace(int c)
4221 {
4222 int result= (int) isspace(c);
4223 dbgprintf("isspace(0x%x='%c' => %d\n", c, c, result);
4224 return result;
4225 }
4226 static int expisalpha(int c)
4227 {
4228 int result= (int) isalpha(c);
4229 dbgprintf("isalpha(0x%x='%c' => %d\n", c, c, result);
4230 return result;
4231 }
4232 static int expisdigit(int c)
4233 {
4234 int result= (int) isdigit(c);
4235 dbgprintf("isdigit(0x%x='%c' => %d\n", c, c, result);
4236 return result;
4237 }
4238 static void* expmemmove(void* dest, void* src, int n)
4239 {
4240 void* result = memmove(dest, src, n);
4241 dbgprintf("memmove(0x%x, 0x%x, %d) => %p\n", dest, src, n, result);
4242 return result;
4243 }
4244 static int expmemcmp(void* dest, void* src, int n)
4245 {
4246 int result = memcmp(dest, src, n);
4247 dbgprintf("memcmp(0x%x, 0x%x, %d) => %d\n", dest, src, n, result);
4248 return result;
4249 }
4250 static void* expmemcpy(void* dest, void* src, int n)
4251 {
4252 void *result = memcpy(dest, src, n);
4253 dbgprintf("memcpy(0x%x, 0x%x, %d) => %p\n", dest, src, n, result);
4254 return result;
4255 }
4256 static void* expmemset(void* dest, int c, size_t n)
4257 {
4258 void *result = memset(dest, c, n);
4259 dbgprintf("memset(0x%x, %d, %d) => %p\n", dest, c, n, result);
4260 return result;
4261 }
4262 static time_t exptime(time_t* t)
4263 {
4264 time_t result = time(t);
4265 dbgprintf("time(0x%x) => %d\n", t, result);
4266 return result;
4267 }
4268
4269 static int exprand(void)
4270 {
4271 return rand();
4272 }
4273
4274 static void expsrand(int seed)
4275 {
4276 srand(seed);
4277 }
4278
4279 #if 1
4280
4281 // preferred compilation with -O2 -ffast-math !
4282
4283 static double explog10(double x)
4284 {
4285 /*printf("Log10 %f => %f 0x%Lx\n", x, log10(x), *((int64_t*)&x));*/
4286 return log10(x);
4287 }
4288
4289 static double expcos(double x)
4290 {
4291 /*printf("Cos %f => %f 0x%Lx\n", x, cos(x), *((int64_t*)&x));*/
4292 return cos(x);
4293 }
4294
4295 /* doens't work */
4296 static long exp_ftol_wrong(double x)
4297 {
4298 return (long) x;
4299 }
4300
4301 #else
4302
4303 static void explog10(void)
4304 {
4305 __asm__ __volatile__
4306 (
4307 "fldl 8(%esp) \n\t"
4308 "fldln2 \n\t"
4309 "fxch %st(1) \n\t"
4310 "fyl2x \n\t"
4311 );
4312 }
4313
4314 static void expcos(void)
4315 {
4316 __asm__ __volatile__
4317 (
4318 "fldl 8(%esp) \n\t"
4319 "fcos \n\t"
4320 );
4321 }
4322
4323 #endif
4324
4325 // this seem to be the only how to make this function working properly
4326 // ok - I've spent tremendous amount of time (many many many hours
4327 // of debuging fixing & testing - it's almost unimaginable - kabi
4328
4329 // _ftol - operated on the float value which is already on the FPU stack
4330
4331 static void exp_ftol(void)
4332 {
4333 __asm__ __volatile__
4334 (
4335 "sub $12, %esp \n\t"
4336 "fstcw -2(%ebp) \n\t"
4337 "wait \n\t"
4338 "movw -2(%ebp), %ax \n\t"
4339 "orb $0x0C, %ah \n\t"
4340 "movw %ax, -4(%ebp) \n\t"
4341 "fldcw -4(%ebp) \n\t"
4342 "fistpl -12(%ebp) \n\t"
4343 "fldcw -2(%ebp) \n\t"
4344 "movl -12(%ebp), %eax \n\t"
4345 //Note: gcc 3.03 does not do the following op if it
4346 // knows that ebp=esp
4347 "movl %ebp, %esp \n\t"
4348 );
4349 }
4350
4351 #define FPU_DOUBLES(var1,var2) double var1,var2; \
4352 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
4353 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
4354
4355 static double exp_CIpow(void)
4356 {
4357 FPU_DOUBLES(x,y);
4358
4359 dbgprintf("_CIpow(%lf, %lf)\n", x, y);
4360 return pow(x, y);
4361 }
4362
4363 static double exppow(double x, double y)
4364 {
4365 /*printf("Pow %f %f 0x%Lx 0x%Lx => %f\n", x, y, *((int64_t*)&x), *((int64_t*)&y), pow(x, y));*/
4366 return pow(x, y);
4367 }
4368
4369 static double expldexp(double x, int expo)
4370 {
4371 /*printf("Cos %f => %f 0x%Lx\n", x, cos(x), *((int64_t*)&x));*/
4372 return ldexp(x, expo);
4373 }
4374
4375 static double expfrexp(double x, int* expo)
4376 {
4377 /*printf("Cos %f => %f 0x%Lx\n", x, cos(x), *((int64_t*)&x));*/
4378 return frexp(x, expo);
4379 }
4380
4381
4382
4383 static int exp_stricmp(const char* s1, const char* s2)
4384 {
4385 return strcasecmp(s1, s2);
4386 }
4387
4388 /* from declaration taken from Wine sources - this fountion seems to be
4389 * undocumented in any M$ doc */
4390 static int exp_setjmp3(void* jmpbuf, int x)
4391 {
4392 //dbgprintf("!!!!UNIMPLEMENTED: setjmp3(%p, %d) => 0\n", jmpbuf, x);
4393 //return 0;
4394 __asm__ __volatile__
4395 (
4396 //"mov 4(%%esp), %%edx \n\t"
4397 "mov (%%esp), %%eax \n\t"
4398 "mov %%eax, (%%edx) \n\t" // store ebp
4399
4400 //"mov %%ebp, (%%edx) \n\t"
4401 "mov %%ebx, 4(%%edx) \n\t"
4402 "mov %%edi, 8(%%edx) \n\t"
4403 "mov %%esi, 12(%%edx) \n\t"
4404 "mov %%esp, 16(%%edx) \n\t"
4405
4406 "mov 4(%%esp), %%eax \n\t"
4407 "mov %%eax, 20(%%edx) \n\t"
4408
4409 "movl $0x56433230, 32(%%edx) \n\t" // VC20 ??
4410 "movl $0, 36(%%edx) \n\t"
4411 : // output
4412 : "d"(jmpbuf) // input
4413 : "eax"
4414 );
4415 #if 1
4416 __asm__ __volatile__
4417 (
4418 "mov %%fs:0, %%eax \n\t" // unsure
4419 "mov %%eax, 24(%%edx) \n\t"
4420 "cmp $0xffffffff, %%eax \n\t"
4421 "jnz l1 \n\t"
4422 "mov %%eax, 28(%%edx) \n\t"
4423 "l1: \n\t"
4424 :
4425 :
4426 : "eax"
4427 );
4428 #endif
4429
4430 return 0;
4431 }
4432
4433 static DWORD WINAPI expGetCurrentProcessId(void)
4434 {
4435 dbgprintf("GetCurrentProcessId(void) => %d\n", getpid());
4436 return getpid(); //(DWORD)NtCurrentTeb()->pid;
4437 }
4438
4439
4440 typedef struct {
4441 UINT wPeriodMin;
4442 UINT wPeriodMax;
4443 } TIMECAPS, *LPTIMECAPS;
4444
4445 static MMRESULT WINAPI exptimeGetDevCaps(LPTIMECAPS lpCaps, UINT wSize)
4446 {
4447 dbgprintf("timeGetDevCaps(%p, %u) !\n", lpCaps, wSize);
4448
4449 lpCaps->wPeriodMin = 1;
4450 lpCaps->wPeriodMax = 65535;
4451 return 0;
4452 }
4453
4454 static MMRESULT WINAPI exptimeBeginPeriod(UINT wPeriod)
4455 {
4456 dbgprintf("timeBeginPeriod(%u) !\n", wPeriod);
4457
4458 if (wPeriod < 1 || wPeriod > 65535) return 96+1; //TIMERR_NOCANDO;
4459 return 0;
4460 }
4461
4462 #ifdef QTX
4463 static MMRESULT WINAPI exptimeEndPeriod(UINT wPeriod)
4464 {
4465 dbgprintf("timeEndPeriod(%u) !\n", wPeriod);
4466
4467 if (wPeriod < 1 || wPeriod > 65535) return 96+1; //TIMERR_NOCANDO;
4468 return 0;
4469 }
4470 #endif
4471
4472 static void WINAPI expGlobalMemoryStatus(
4473 LPMEMORYSTATUS lpmem
4474 ) {
4475 static MEMORYSTATUS cached_memstatus;
4476 static int cache_lastchecked = 0;
4477 SYSTEM_INFO si;
4478 FILE *f;
4479
4480 if (time(NULL)==cache_lastchecked) {
4481 memcpy(lpmem,&cached_memstatus,sizeof(MEMORYSTATUS));
4482 return;
4483 }
4484
4485 #if 1
4486 f = fopen( "/proc/meminfo", "r" );
4487 if (f)
4488 {
4489 char buffer[256];
4490 int total, used, free, shared, buffers, cached;
4491
4492 lpmem->dwLength = sizeof(MEMORYSTATUS);
4493 lpmem->dwTotalPhys = lpmem->dwAvailPhys = 0;
4494 lpmem->dwTotalPageFile = lpmem->dwAvailPageFile = 0;
4495 while (fgets( buffer, sizeof(buffer), f ))
4496 {
4497 /* old style /proc/meminfo ... */
4498 if (sscanf( buffer, "Mem: %d %d %d %d %d %d", &total, &used, &free, &shared, &buffers, &cached ))
4499 {
4500 lpmem->dwTotalPhys += total;
4501 lpmem->dwAvailPhys += free + buffers + cached;
4502 }
4503 if (sscanf( buffer, "Swap: %d %d %d", &total, &used, &free ))
4504 {
4505 lpmem->dwTotalPageFile += total;
4506 lpmem->dwAvailPageFile += free;
4507 }
4508
4509 /* new style /proc/meminfo ... */
4510 if (sscanf(buffer, "MemTotal: %d", &total))
4511 lpmem->dwTotalPhys = total*1024;
4512 if (sscanf(buffer, "MemFree: %d", &free))
4513 lpmem->dwAvailPhys = free*1024;
4514 if (sscanf(buffer, "SwapTotal: %d", &total))
4515 lpmem->dwTotalPageFile = total*1024;
4516 if (sscanf(buffer, "SwapFree: %d", &free))
4517 lpmem->dwAvailPageFile = free*1024;
4518 if (sscanf(buffer, "Buffers: %d", &buffers))
4519 lpmem->dwAvailPhys += buffers*1024;
4520 if (sscanf(buffer, "Cached: %d", &cached))
4521 lpmem->dwAvailPhys += cached*1024;
4522 }
4523 fclose( f );
4524
4525 if (lpmem->dwTotalPhys)
4526 {
4527 DWORD TotalPhysical = lpmem->dwTotalPhys+lpmem->dwTotalPageFile;
4528 DWORD AvailPhysical = lpmem->dwAvailPhys+lpmem->dwAvailPageFile;
4529 lpmem->dwMemoryLoad = (TotalPhysical-AvailPhysical)
4530 / (TotalPhysical / 100);
4531 }
4532 } else
4533 #endif
4534 {
4535 /* FIXME: should do something for other systems */
4536 lpmem->dwMemoryLoad = 0;
4537 lpmem->dwTotalPhys = 16*1024*1024;
4538 lpmem->dwAvailPhys = 16*1024*1024;
4539 lpmem->dwTotalPageFile = 16*1024*1024;
4540 lpmem->dwAvailPageFile = 16*1024*1024;
4541 }
4542 expGetSystemInfo(&si);
4543 lpmem->dwTotalVirtual = si.lpMaximumApplicationAddress-si.lpMinimumApplicationAddress;
4544 /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
4545 lpmem->dwAvailVirtual = lpmem->dwTotalVirtual-64*1024;
4546 memcpy(&cached_memstatus,lpmem,sizeof(MEMORYSTATUS));
4547 cache_lastchecked = time(NULL);
4548
4549 /* it appears some memory display programs want to divide by these values */
4550 if(lpmem->dwTotalPageFile==0)
4551 lpmem->dwTotalPageFile++;
4552
4553 if(lpmem->dwAvailPageFile==0)
4554 lpmem->dwAvailPageFile++;
4555 }
4556
4557 /**********************************************************************
4558 * SetThreadPriority [KERNEL32.@] Sets priority for thread.
4559 *
4560 * RETURNS
4561 * Success: TRUE
4562 * Failure: FALSE
4563 */
4564 static WIN_BOOL WINAPI expSetThreadPriority(
4565 HANDLE hthread, /* [in] Handle to thread */
4566 INT priority) /* [in] Thread priority level */
4567 {
4568 dbgprintf("SetThreadPriority(%p,%d)\n",hthread,priority);
4569 return TRUE;
4570 }
4571
4572 static void WINAPI expExitProcess( DWORD status )
4573 {
4574 printf("EXIT - code %ld\n",status);
4575 exit(status);
4576 }
4577
4578 static INT WINAPI expMessageBoxA(HWND hWnd, LPCSTR text, LPCSTR title, UINT type){
4579 printf("MSGBOX '%s' '%s' (%d)\n",text,title,type);
4580 #ifdef QTX
4581 if (type == MB_ICONHAND && !strlen(text) && !strlen(title))
4582 return IDIGNORE;
4583 #endif
4584 return IDOK;
4585 }
4586
4587 /* these are needed for mss1 */
4588
4589 /* defined in stubs.s */
4590 void exp_EH_prolog(void);
4591
4592 #include <netinet/in.h>
4593 static WINAPI inline unsigned long int exphtonl(unsigned long int hostlong)
4594 {
4595 // dbgprintf("htonl(%x) => %x\n", hostlong, htonl(hostlong));
4596 return htonl(hostlong);
4597 }
4598
4599 static WINAPI inline unsigned long int expntohl(unsigned long int netlong)
4600 {
4601 // dbgprintf("ntohl(%x) => %x\n", netlong, ntohl(netlong));
4602 return ntohl(netlong);
4603 }
4604 static void WINAPI expVariantInit(void* p)
4605 {
4606 printf("InitCommonControls called!\n");
4607 return;
4608 }
4609
4610 static int WINAPI expRegisterClassA(const void/*WNDCLASSA*/ *wc)
4611 {
4612 dbgprintf("RegisterClassA(%p) => random id\n", wc);
4613 return time(NULL); /* be precise ! */
4614 }
4615
4616 static int WINAPI expUnregisterClassA(const char *className, HINSTANCE hInstance)
4617 {
4618 dbgprintf("UnregisterClassA(%s, %p) => 0\n", className, hInstance);
4619 return 0;
4620 }
4621
4622 #ifdef QTX
4623 /* should be fixed bcs it's not fully strlen equivalent */
4624 static int expSysStringByteLen(void *str)
4625 {
4626 dbgprintf("SysStringByteLen(%p) => %d\n", str, strlen(str));
4627 return strlen(str);
4628 }
4629
4630 static int expDirectDrawCreate(void)
4631 {
4632 dbgprintf("DirectDrawCreate(...) => NULL\n");
4633 return 0;
4634 }
4635
4636 #if 1
4637 typedef struct tagPALETTEENTRY {
4638 BYTE peRed;
4639 BYTE peGreen;
4640 BYTE peBlue;
4641 BYTE peFlags;
4642 } PALETTEENTRY;
4643
4644 /* reversed the first 2 entries */
4645 typedef struct tagLOGPALETTE {
4646 WORD palNumEntries;
4647 WORD palVersion;
4648 PALETTEENTRY palPalEntry[1];
4649 } LOGPALETTE;
4650
4651 static HPALETTE WINAPI expCreatePalette(CONST LOGPALETTE *lpgpl)
4652 {
4653 HPALETTE test;
4654 int i;
4655
4656 dbgprintf("CreatePalette(%x) => NULL\n", lpgpl);
4657
4658 i = sizeof(LOGPALETTE)+((lpgpl->palNumEntries-1)*sizeof(PALETTEENTRY));
4659 test = (HPALETTE)malloc(i);
4660 memcpy((void *)test, lpgpl, i);
4661
4662 return test;
4663 }
4664 #else
4665 static int expCreatePalette(void)
4666 {
4667 dbgprintf("CreatePalette(...) => NULL\n");
4668 return NULL;
4669 }
4670 #endif
4671
4672 static int WINAPI expGetClientRect(HWND win, RECT *r)
4673 {
4674 dbgprintf("GetClientRect(0x%x, 0x%x) => 1\n", win, r);
4675 r->right = PSEUDO_SCREEN_WIDTH;
4676 r->left = 0;
4677 r->bottom = PSEUDO_SCREEN_HEIGHT;
4678 r->top = 0;
4679 return 1;
4680 }
4681
4682 #if 0
4683 typedef struct tagPOINT {
4684 LONG x;
4685 LONG y;
4686 } POINT, *PPOINT;
4687 #endif
4688
4689 static int WINAPI expClientToScreen(HWND win, POINT *p)
4690 {
4691 dbgprintf("ClientToScreen(0x%x, 0x%x = %d,%d) => 1\n", win, p, p->x, p->y);
4692 p->x = 0;
4693 p->y = 0;
4694 return 1;
4695 }
4696 #endif
4697
4698 /* for m3jpeg */
4699 static int WINAPI expSetThreadIdealProcessor(HANDLE thread, int proc)
4700 {
4701 dbgprintf("SetThreadIdealProcessor(0x%x, %x) => 0\n", thread, proc);
4702 return 0;
4703 }
4704
4705 static int WINAPI expMessageBeep(int type)
4706 {
4707 dbgprintf("MessageBeep(%d) => 1\n", type);
4708 return 1;
4709 }
4710
4711 static int WINAPI expDialogBoxParamA(void *inst, const char *name,
4712 HWND parent, void *dialog_func, void *init_param)
4713 {
4714 dbgprintf("DialogBoxParamA(0x%x, 0x%x = %s, 0x%x, 0x%x, 0x%x) => 0x42424242\n",
4715 inst, name, name, parent, dialog_func, init_param);
4716 return 0x42424242;
4717 }
4718
4719 /* needed by imagepower mjpeg2k */
4720 static void *exprealloc(void *ptr, size_t size)
4721 {
4722 dbgprintf("realloc(0x%x, %x)\n", ptr, size);
4723 if (!ptr)
4724 return my_mreq(size,0);
4725 else
4726 return my_realloc(ptr, size);
4727 }
4728
4729 /* Fake GetOpenFileNameA from comdlg32.dll for ViVD codec */
4730 static WIN_BOOL WINAPI expGetOpenFileNameA(/*LPOPENFILENAMEA*/ void* lpfn)
4731 {
4732 return 1;
4733 }
4734
4735 static double expfloor(double x)
4736 {
4737 dbgprintf("floor(%lf)\n", x);
4738 return floor(x);
4739 }
4740
4741 #define FPU_DOUBLE(var) double var; \
4742 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
4743
4744 static double exp_CIcos(void)
4745 {
4746 FPU_DOUBLE(x);
4747
4748 dbgprintf("_CIcos(%lf)\n", x);
4749 return cos(x);
4750 }
4751
4752 static double exp_CIsin(void)
4753 {
4754 FPU_DOUBLE(x);
4755
4756 dbgprintf("_CIsin(%lf)\n", x);
4757 return sin(x);
4758 }
4759
4760 struct exports
4761 {
4762 char name[64];
4763 int id;
4764 void* func;
4765 };
4766 struct libs
4767 {
4768 char name[64];
4769 int length;
4770 struct exports* exps;
4771 };
4772
4773 #define FF(X,Y) \
4774 {#X, Y, (void*)exp##X},
4775
4776 struct exports exp_kernel32[]=
4777 {
4778 FF(GetVolumeInformationA,-1)
4779 FF(GetDriveTypeA,-1)
4780 FF(GetLogicalDriveStringsA,-1)
4781 FF(IsBadWritePtr, 357)
4782 FF(IsBadReadPtr, 354)
4783 FF(IsBadStringPtrW, -1)
4784 FF(IsBadStringPtrA, -1)
4785 FF(DisableThreadLibraryCalls, -1)
4786 FF(CreateThread, -1)
4787 FF(CreateEventA, -1)
4788 FF(SetEvent, -1)
4789 FF(ResetEvent, -1)
4790 FF(WaitForSingleObject, -1)
4791 #ifdef QTX
4792 FF(WaitForMultipleObjects, -1)
4793 FF(ExitThread, -1)
4794 FF(CreateMutexA,-1)
4795 FF(ReleaseMutex,-1)
4796 #endif
4797 FF(GetSystemInfo, -1)
4798 FF(GetVersion, 332)
4799 FF(HeapCreate, 461)
4800 FF(HeapAlloc, -1)
4801 FF(HeapDestroy, -1)
4802 FF(HeapFree, -1)
4803 FF(HeapSize, -1)
4804 FF(HeapReAlloc,-1)
4805 FF(GetProcessHeap, -1)
4806 FF(VirtualAlloc, -1)
4807 FF(VirtualFree, -1)
4808 FF(InitializeCriticalSection, -1)
4809 FF(EnterCriticalSection, -1)
4810 FF(LeaveCriticalSection, -1)
4811 FF(DeleteCriticalSection, -1)
4812 FF(TlsAlloc, -1)
4813 FF(TlsFree, -1)
4814 FF(TlsGetValue, -1)
4815 FF(TlsSetValue, -1)
4816 FF(GetCurrentThreadId, -1)
4817 FF(GetCurrentProcess, -1)
4818 FF(LocalAlloc, -1)
4819 FF(LocalReAlloc,-1)
4820 FF(LocalLock, -1)
4821 FF(GlobalAlloc, -1)
4822 FF(GlobalReAlloc, -1)
4823 FF(GlobalLock, -1)
4824 FF(GlobalSize, -1)
4825 FF(MultiByteToWideChar, 427)
4826 FF(WideCharToMultiByte, -1)
4827 FF(GetVersionExA, -1)
4828 FF(CreateSemaphoreA, -1)
4829 FF(QueryPerformanceCounter, -1)
4830 FF(QueryPerformanceFrequency, -1)
4831 FF(LocalHandle, -1)
4832 FF(LocalUnlock, -1)
4833 FF(LocalFree, -1)
4834 FF(GlobalHandle, -1)
4835 FF(GlobalUnlock, -1)
4836 FF(GlobalFree, -1)
4837 FF(LoadResource, -1)
4838 FF(ReleaseSemaphore, -1)
4839 FF(FindResourceA, -1)
4840 FF(LockResource, -1)
4841 FF(FreeResource, -1)
4842 FF(SizeofResource, -1)
4843 FF(CloseHandle, -1)
4844 FF(GetCommandLineA, -1)
4845 FF(GetEnvironmentStringsW, -1)
4846 FF(FreeEnvironmentStringsW, -1)
4847 FF(FreeEnvironmentStringsA, -1)
4848 FF(GetEnvironmentStrings, -1)
4849 FF(GetStartupInfoA, -1)
4850 FF(GetStdHandle, -1)
4851 FF(GetFileType, -1)
4852 #ifdef QTX
4853 FF(GetFileAttributesA, -1)
4854 #endif
4855 FF(SetHandleCount, -1)
4856 FF(GetACP, -1)
4857 FF(GetModuleFileNameA, -1)
4858 FF(SetUnhandledExceptionFilter, -1)
4859 FF(LoadLibraryA, -1)
4860 FF(GetProcAddress, -1)
4861 FF(FreeLibrary, -1)
4862 FF(CreateFileMappingA, -1)
4863 FF(OpenFileMappingA, -1)
4864 FF(MapViewOfFile, -1)
4865 FF(UnmapViewOfFile, -1)
4866 FF(Sleep, -1)
4867 FF(GetModuleHandleA, -1)
4868 FF(GetProfileIntA, -1)
4869 FF(GetPrivateProfileIntA, -1)
4870 FF(GetPrivateProfileStringA, -1)
4871 FF(WritePrivateProfileStringA, -1)
4872 FF(GetLastError, -1)
4873 FF(SetLastError, -1)
4874 FF(InterlockedIncrement, -1)
4875 FF(InterlockedDecrement, -1)
4876 FF(GetTimeZoneInformation, -1)
4877 FF(OutputDebugStringA, -1)
4878 FF(GetLocalTime, -1)
4879 FF(GetSystemTime, -1)
4880 FF(GetSystemTimeAsFileTime, -1)
4881 FF(GetEnvironmentVariableA, -1)
4882 FF(SetEnvironmentVariableA, -1)
4883 FF(RtlZeroMemory,-1)
4884 FF(RtlMoveMemory,-1)
4885 FF(RtlFillMemory,-1)
4886 FF(GetTempPathA,-1)
4887 FF(FindFirstFileA,-1)
4888 FF(FindNextFileA,-1)
4889 FF(FindClose,-1)
4890 FF(FileTimeToLocalFileTime,-1)
4891 FF(DeleteFileA,-1)
4892 FF(ReadFile,-1)
4893 FF(WriteFile,-1)
4894 FF(SetFilePointer,-1)
4895 FF(GetTempFileNameA,-1)
4896 FF(CreateFileA,-1)
4897 FF(GetSystemDirectoryA,-1)
4898 FF(GetWindowsDirectoryA,-1)
4899 #ifdef QTX
4900 FF(GetCurrentDirectoryA,-1)
4901 FF(SetCurrentDirectoryA,-1)
4902 FF(CreateDirectoryA,-1)
4903 #endif
4904 FF(GetShortPathNameA,-1)
4905 FF(GetFullPathNameA,-1)
4906 FF(SetErrorMode, -1)
4907 FF(IsProcessorFeaturePresent, -1)
4908 FF(GetProcessAffinityMask, -1)
4909 FF(InterlockedExchange, -1)
4910 FF(InterlockedCompareExchange, -1)
4911 FF(MulDiv, -1)
4912 FF(lstrcmpiA, -1)
4913 FF(lstrlenA, -1)
4914 FF(lstrcpyA, -1)
4915 FF(lstrcatA, -1)
4916 FF(lstrcpynA,-1)
4917 FF(GetProcessVersion,-1)
4918 FF(GetCurrentThread,-1)
4919 FF(GetOEMCP,-1)
4920 FF(GetCPInfo,-1)
4921 FF(DuplicateHandle,-1)
4922 FF(GetTickCount, -1)
4923 FF(SetThreadAffinityMask,-1)
4924 FF(GetCurrentProcessId,-1)
4925 FF(GlobalMemoryStatus,-1)
4926 FF(SetThreadPriority,-1)
4927 FF(ExitProcess,-1)
4928 {"LoadLibraryExA", -1, (void*)&LoadLibraryExA},
4929 FF(SetThreadIdealProcessor,-1)
4930 };
4931
4932 struct exports exp_msvcrt[]={
4933 FF(malloc, -1)
4934 FF(_initterm, -1)
4935 FF(__dllonexit, -1)
4936 FF(_snprintf,-1)
4937 FF(free, -1)
4938 {"??3@YAXPAX@Z", -1, expdelete},
4939 {"??2@YAPAXI@Z", -1, expnew},
4940 {"_adjust_fdiv", -1, (void*)&_adjust_fdiv},
4941 FF(strrchr, -1)
4942 FF(strchr, -1)
4943 FF(strlen, -1)
4944 FF(strcpy, -1)
4945 FF(strncpy, -1)
4946 FF(wcscpy, -1)
4947 FF(strcmp, -1)
4948 FF(strncmp, -1)
4949 FF(strcat, -1)
4950 FF(_stricmp,-1)
4951 FF(_strdup,-1)
4952 FF(_setjmp3,-1)
4953 FF(isalnum, -1)
4954 FF(isspace, -1)
4955 FF(isalpha, -1)
4956 FF(isdigit, -1)
4957 FF(memmove, -1)
4958 FF(memcmp, -1)
4959 FF(memset, -1)
4960 FF(memcpy, -1)
4961 FF(time, -1)
4962 FF(rand, -1)
4963 FF(srand, -1)
4964 FF(log10, -1)
4965 FF(pow, -1)
4966 FF(cos, -1)
4967 FF(_ftol,-1)
4968 FF(_CIpow,-1)
4969 FF(_CIcos,-1)
4970 FF(_CIsin,-1)
4971 FF(ldexp,-1)
4972 FF(frexp,-1)
4973 FF(sprintf,-1)
4974 FF(sscanf,-1)
4975 FF(fopen,-1)
4976 FF(fprintf,-1)
4977 FF(printf,-1)
4978 FF(getenv,-1)
4979 FF(floor,-1)
4980 /* needed by frapsvid.dll */
4981 {"strstr",-1,(char *)&strstr},
4982 {"qsort",-1,(void *)&qsort},
4983 #ifdef MPLAYER
4984 FF(_EH_prolog,-1)
4985 #endif
4986 FF(calloc,-1)
4987 {"ceil",-1,(void*)&ceil},
4988 /* needed by imagepower mjpeg2k */
4989 {"clock",-1,(void*)&clock},
4990 {"memchr",-1,(void*)&memchr},
4991 {"vfprintf",-1,(void*)&vfprintf},
4992 // {"realloc",-1,(void*)&realloc},
4993 FF(realloc,-1)
4994 {"puts",-1,(void*)&puts}
4995 };
4996 struct exports exp_winmm[]={
4997 FF(GetDriverModuleHandle, -1)
4998 FF(timeGetTime, -1)
4999 FF(DefDriverProc, -1)
5000 FF(OpenDriverA, -1)
5001 FF(OpenDriver, -1)
5002 FF(timeGetDevCaps, -1)
5003 FF(timeBeginPeriod, -1)
5004 #ifdef QTX
5005 FF(timeEndPeriod, -1)
5006 FF(waveOutGetNumDevs, -1)
5007 #endif
5008 };
5009 struct exports exp_user32[]={
5010 FF(LoadIconA,-1)
5011 FF(LoadStringA, -1)
5012 FF(wsprintfA, -1)
5013 FF(GetDC, -1)
5014 FF(GetDesktopWindow, -1)
5015 FF(ReleaseDC, -1)
5016 FF(IsRectEmpty, -1)
5017 FF(LoadCursorA,-1)
5018 FF(SetCursor,-1)
5019 FF(GetCursorPos,-1)
5020 #ifdef QTX
5021 FF(ShowCursor,-1)
5022 #endif
5023 FF(RegisterWindowMessageA,-1)
5024 FF(GetSystemMetrics,-1)
5025 FF(GetSysColor,-1)
5026 FF(GetSysColorBrush,-1)
5027 FF(GetWindowDC, -1)
5028 FF(DrawTextA, -1)
5029 FF(MessageBoxA, -1)
5030 FF(RegisterClassA, -1)
5031 FF(UnregisterClassA, -1)
5032 #ifdef QTX
5033 FF(GetWindowRect, -1)
5034 FF(MonitorFromWindow, -1)
5035 FF(MonitorFromRect, -1)
5036 FF(MonitorFromPoint, -1)
5037 FF(EnumDisplayMonitors, -1)
5038 FF(GetMonitorInfoA, -1)
5039 FF(EnumDisplayDevicesA, -1)
5040 FF(GetClientRect, -1)
5041 FF(ClientToScreen, -1)
5042 FF(IsWindowVisible, -1)
5043 FF(GetActiveWindow, -1)
5044 FF(GetClassNameA, -1)
5045 FF(GetClassInfoA, -1)
5046 FF(GetWindowLongA, -1)
5047 FF(EnumWindows, -1)
5048 FF(GetWindowThreadProcessId, -1)
5049 FF(CreateWindowExA, -1)
5050 #endif
5051 FF(MessageBeep, -1)
5052 FF(DialogBoxParamA, -1)
5053 };
5054 struct exports exp_advapi32[]={
5055 FF(RegCloseKey, -1)
5056 FF(RegCreateKeyA, -1)
5057 FF(RegCreateKeyExA, -1)
5058 FF(RegEnumKeyExA, -1)
5059 FF(RegEnumValueA, -1)
5060 FF(RegOpenKeyA, -1)
5061 FF(RegOpenKeyExA, -1)
5062 FF(RegQueryValueExA, -1)
5063 FF(RegSetValueExA, -1)
5064 FF(RegQueryInfoKeyA, -1)
5065 };
5066 struct exports exp_gdi32[]={
5067 FF(CreateCompatibleDC, -1)
5068 FF(CreateFontA, -1)
5069 FF(DeleteDC, -1)
5070 FF(DeleteObject, -1)
5071 FF(GetDeviceCaps, -1)
5072 FF(GetSystemPaletteEntries, -1)
5073 #ifdef QTX
5074 FF(CreatePalette, -1)
5075 FF(GetObjectA, -1)
5076 FF(CreateRectRgn, -1)
5077 #endif
5078 };
5079 struct exports exp_version[]={
5080 FF(GetFileVersionInfoSizeA, -1)
5081 };
5082 struct exports exp_ole32[]={
5083 FF(CoCreateFreeThreadedMarshaler,-1)
5084 FF(CoCreateInstance, -1)
5085 FF(CoInitialize, -1)
5086 FF(CoTaskMemAlloc, -1)
5087 FF(CoTaskMemFree, -1)
5088 FF(StringFromGUID2, -1)
5089 };
5090 // do we really need crtdll ???
5091 // msvcrt is the correct place probably...
5092 struct exports exp_crtdll[]={
5093 FF(memcpy, -1)
5094 FF(wcscpy, -1)
5095 };
5096 struct exports exp_comctl32[]={
5097 FF(StringFromGUID2, -1)
5098 FF(InitCommonControls, 17)
5099 #ifdef QTX
5100 FF(CreateUpDownControl, 16)
5101 #endif
5102 };
5103 struct exports exp_wsock32[]={
5104 FF(htonl,8)
5105 FF(ntohl,14)
5106 };
5107 struct exports exp_msdmo[]={
5108 FF(memcpy, -1) // just test
5109 FF(MoCopyMediaType, -1)
5110 FF(MoCreateMediaType, -1)
5111 FF(MoDeleteMediaType, -1)
5112 FF(MoDuplicateMediaType, -1)
5113 FF(MoFreeMediaType, -1)
5114 FF(MoInitMediaType, -1)
5115 };
5116 struct exports exp_oleaut32[]={
5117 FF(VariantInit, 8)
5118 #ifdef QTX
5119 FF(SysStringByteLen, 149)
5120 #endif
5121 };
5122
5123 /* realplayer8:
5124 DLL Name: PNCRT.dll
5125 vma: Hint/Ord Member-Name
5126 22ff4 615 free
5127 2302e 250 _ftol
5128 22fea 666 malloc
5129 2303e 609 fprintf
5130 2305e 167 _adjust_fdiv
5131 23052 280 _initterm
5132
5133 22ffc 176 _beginthreadex
5134 23036 284 _iob
5135 2300e 85 __CxxFrameHandler
5136 23022 411 _purecall
5137 */
5138 #ifdef REALPLAYER
5139 struct exports exp_pncrt[]={
5140 FF(malloc, -1) // just test
5141 FF(free, -1) // just test
5142 FF(fprintf, -1) // just test
5143 {"_adjust_fdiv", -1, (void*)&_adjust_fdiv},
5144 FF(_ftol,-1)
5145 FF(_initterm, -1)
5146 {"??3@YAXPAX@Z", -1, expdelete},
5147 {"??2@YAPAXI@Z", -1, expnew},
5148 FF(__dllonexit, -1)
5149 FF(strncpy, -1)
5150 FF(_CIpow,-1)
5151 FF(calloc,-1)
5152 FF(memmove, -1)
5153 };
5154 #endif
5155
5156 #ifdef QTX
5157 struct exports exp_ddraw[]={
5158 FF(DirectDrawCreate, -1)
5159 };
5160 #endif
5161
5162 struct exports exp_comdlg32[]={
5163 FF(GetOpenFileNameA, -1)
5164 };
5165
5166 #define LL(X) \
5167 {#X".dll", sizeof(exp_##X)/sizeof(struct exports), exp_##X},
5168
5169 struct libs libraries[]={
5170 LL(kernel32)
5171 LL(msvcrt)
5172 LL(winmm)
5173 LL(user32)
5174 LL(advapi32)
5175 LL(gdi32)
5176 LL(version)
5177 LL(ole32)
5178 LL(oleaut32)
5179 LL(crtdll)
5180 LL(comctl32)
5181 LL(wsock32)
5182 LL(msdmo)
5183 #ifdef REALPLAYER
5184 LL(pncrt)
5185 #endif
5186 #ifdef QTX
5187 LL(ddraw)
5188 #endif
5189 LL(comdlg32)
5190 };
5191
5192 static void ext_stubs(void)
5193 {
5194 // expects:
5195 // ax position index
5196 // cx address of printf function
5197 #if 1
5198 __asm__ __volatile__
5199 (
5200 "push %%edx \n\t"
5201 "movl $0xdeadbeef, %%eax \n\t"
5202 "movl $0xdeadbeef, %%edx \n\t"
5203 "shl $5, %%eax \n\t" // ax * 32
5204 "addl $0xdeadbeef, %%eax \n\t" // overwrite export_names
5205 "pushl %%eax \n\t"
5206 "pushl $0xdeadbeef \n\t" // overwrite called_unk
5207 "call *%%edx \n\t" // printf (via dx)
5208 "addl $8, %%esp \n\t"
5209 "xorl %%eax, %%eax \n\t"
5210 "pop %%edx \n\t"
5211 :
5212 :
5213 : "eax"
5214 );
5215 #else
5216 __asm__ __volatile__
5217 (
5218 "push %%edx \n\t"
5219 "movl $0, %%eax \n\t"
5220 "movl $0, %%edx \n\t"
5221 "shl $5, %%eax \n\t" // ax * 32
5222 "addl %0, %%eax \n\t"
5223 "pushl %%eax \n\t"
5224 "pushl %1 \n\t"
5225 "call *%%edx \n\t" // printf (via dx)
5226 "addl $8, %%esp \n\t"
5227 "xorl %%eax, %%eax \n\t"
5228 "pop %%edx \n\t"
5229 ::"m"(*export_names), "m"(*called_unk)
5230 : "memory", "edx", "eax"
5231 );
5232 #endif
5233
5234 }
5235
5236 //static void add_stub(int pos)
5237
5238 extern int unk_exp1;
5239 static int pos=0;
5240 static char extcode[20000];// place for 200 unresolved exports
5241 static const char* called_unk = "Called unk_%s\n";
5242
5243 static void* add_stub(void)
5244 {
5245 // generated code in runtime!
5246 char* answ = (char*)extcode+pos*0x30;
5247 #if 0
5248 memcpy(answ, &unk_exp1, 0x64);
5249 *(int*)(answ+9)=pos;
5250 *(int*)(answ+47)-=((int)answ-(int)&unk_exp1);
5251 #endif
5252 memcpy(answ, ext_stubs, 0x2f); // 0x2c is current size
5253 //answ[4] = 0xb8; // movl $0, eax (0xb8 0x00000000)
5254 *((int*) (answ + 5)) = pos;
5255 //answ[9] = 0xba; // movl $0, edx (0xba 0x00000000)
5256 *((long*) (answ + 10)) = (long)printf;
5257 //answ[17] = 0x05; // addl $0, eax (0x05 0x00000000)
5258 *((long*) (answ + 18)) = (long)export_names;
5259 //answ[23] = 0x68; // pushl $0 (0x68 0x00000000)
5260 *((long*) (answ + 24)) = (long)called_unk;
5261 pos++;
5262 return (void*)answ;
5263 }
5264
5265 void* LookupExternal(const char* library, int ordinal)
5266 {
5267 int i,j;
5268 if(library==0)
5269 {
5270 printf("ERROR: library=0\n");
5271 return (void*)ext_unknown;
5272 }
5273 // printf("%x %x\n", &unk_exp1, &unk_exp2);
5274
5275 dbgprintf("External func %s:%d\n", library, ordinal);
5276
5277 for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++)
5278 {
5279 if(strcasecmp(library, libraries[i].name))
5280 continue;
5281 for(j=0; j<libraries[i].length; j++)
5282 {
5283 if(ordinal!=libraries[i].exps[j].id)
5284 continue;
5285 //printf("Hit: 0x%p\n", libraries[i].exps[j].func);
5286 return libraries[i].exps[j].func;
5287 }
5288 }
5289
5290 #ifndef LOADLIB_TRY_NATIVE
5291 /* hack for truespeech and vssh264*/
5292 if (!strcmp(library, "tsd32.dll") || !strcmp(library,"vssh264dec.dll") || !strcmp(library,"LCMW2.dll") || !strcmp(library,"VDODEC32.dll"))
5293 #endif
5294 /* ok, this is a hack, and a big memory leak. should be fixed. - alex */
5295 {
5296 int hand;
5297 WINE_MODREF *wm;
5298 void *func;
5299
5300 hand = LoadLibraryA(library);
5301 if (!hand)
5302 goto no_dll;
5303 wm = MODULE32_LookupHMODULE(hand);
5304 if (!wm)
5305 {
5306 FreeLibrary(hand);
5307 goto no_dll;
5308 }
5309 func = PE_FindExportedFunction(wm, (LPCSTR) ordinal, 0);
5310 if (!func)
5311 {
5312 printf("No such ordinal in external dll\n");
5313 FreeLibrary((int)hand);
5314 goto no_dll;
5315 }
5316
5317 printf("External dll loaded (offset: 0x%x, func: %p)\n",
5318 hand, func);
5319 return func;
5320 }
5321
5322 no_dll:
5323 if(pos>150)return 0;
5324 sprintf(export_names[pos], "%s:%d", library, ordinal);
5325 return add_stub();
5326 }
5327
5328 void* LookupExternalByName(const char* library, const char* name)
5329 {
5330 char* answ;
5331 int i,j;
5332 // return (void*)ext_unknown;
5333 if(library==0)
5334 {
5335 printf("ERROR: library=0\n");
5336 return (void*)ext_unknown;
5337 }
5338 if(name==0)
5339 {
5340 printf("ERROR: name=0\n");
5341 return (void*)ext_unknown;
5342 }
5343 dbgprintf("External func %s:%s\n", library, name);
5344 for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++)
5345 {
5346 if(strcasecmp(library, libraries[i].name))
5347 continue;
5348 for(j=0; j<libraries[i].length; j++)
5349 {
5350 if(strcmp(name, libraries[i].exps[j].name))
5351 continue;
5352 // printf("Hit: 0x%08X\n", libraries[i].exps[j].func);
5353 return libraries[i].exps[j].func;
5354 }
5355 }
5356
5357 #ifndef LOADLIB_TRY_NATIVE
5358 /* hack for vss h264 */
5359 if (!strcmp(library,"vssh264core.dll"))
5360 #endif
5361 /* ok, this is a hack, and a big memory leak. should be fixed. - alex */
5362 {
5363 int hand;
5364 WINE_MODREF *wm;
5365 void *func;
5366
5367 hand = LoadLibraryA(library);
5368 if (!hand)
5369 goto no_dll_byname;
5370 wm = MODULE32_LookupHMODULE(hand);
5371 if (!wm)
5372 {
5373 FreeLibrary(hand);
5374 goto no_dll_byname;
5375 }
5376 func = PE_FindExportedFunction(wm, name, 0);
5377 if (!func)
5378 {
5379 printf("No such name in external dll\n");
5380 FreeLibrary((int)hand);
5381 goto no_dll_byname;
5382 }
5383
5384 printf("External dll loaded (offset: 0x%x, func: %p)\n",
5385 hand, func);
5386 return func;
5387 }
5388
5389 no_dll_byname:
5390 if(pos>150)return 0;// to many symbols
5391 strcpy(export_names[pos], name);
5392 return add_stub();
5393 }
5394
5395 void my_garbagecollection(void)
5396 {
5397 #ifdef GARBAGE
5398 int unfree = 0, unfreecnt = 0;
5399
5400 int max_fatal = 8;
5401 free_registry();
5402 while (last_alloc)
5403 {
5404 alloc_header* mem = last_alloc + 1;
5405 unfree += my_size(mem);
5406 unfreecnt++;
5407 if (my_release(mem) != 0)
5408 // avoid endless loop when memory is trashed
5409 if (--max_fatal < 0)
5410 break;
5411 }
5412 dbgprintf("Total Unfree %d bytes cnt %d [%p,%d]\n",unfree, unfreecnt, last_alloc, alccnt);
5413 #endif
5414 g_tls = NULL;
5415 list = NULL;
5416 }