Mercurial > mplayer.hg
annotate loader/win32.c @ 3721:66da035c4ee2
some quick updates for the prerelease
author | gabucino |
---|---|
date | Mon, 24 Dec 2001 23:00:07 +0000 |
parents | 1d48df12001b |
children | 3fd9b781a9d2 |
rev | line source |
---|---|
1 | 1 /*********************************************************** |
2 | |
3465 | 3 Win32 emulation code. Functions that emulate |
4 responses from corresponding Win32 API calls. | |
5 Since we are not going to be able to load | |
6 virtually any DLL, we can only implement this | |
7 much, adding needed functions with each new codec. | |
8 | |
9 Basic principle of implementation: it's not good | |
10 for DLL to know too much about its environment. | |
1 | 11 |
12 ************************************************************/ | |
13 | |
2069 | 14 #include "config.h" |
1 | 15 |
2069 | 16 #include "wine/winbase.h" |
17 #include "wine/winreg.h" | |
18 #include "wine/winnt.h" | |
19 #include "wine/winerror.h" | |
20 #include "wine/debugtools.h" | |
21 #include "wine/module.h" | |
2139 | 22 |
23 #include <stdio.h> | |
1 | 24 #include "win32.h" |
2069 | 25 |
2139 | 26 #include "registry.h" |
27 #include "loader.h" | |
28 #include "com.h" | |
29 | |
2069 | 30 #include <stdlib.h> |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
31 #include <assert.h> |
2139 | 32 #include <stdarg.h> |
2069 | 33 #include <ctype.h> |
1 | 34 #include <pthread.h> |
128 | 35 #include <errno.h> |
1 | 36 #ifdef HAVE_MALLOC_H |
37 #include <malloc.h> | |
38 #endif | |
39 #include <time.h> | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
40 #include <math.h> |
128 | 41 #include <unistd.h> |
42 #include <fcntl.h> | |
1 | 43 #include <sys/types.h> |
44 #include <sys/time.h> | |
45 #include <sys/timeb.h> | |
2069 | 46 #ifdef HAVE_KSTAT |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
47 #include <kstat.h> |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
48 #endif |
1 | 49 |
2906
2ec3ec904cd4
Try to provide a vsscanf() implementation, if the system does not have
jkeil
parents:
2780
diff
changeset
|
50 #if HAVE_VSSCANF |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
51 int vsscanf( const char *str, const char *format, va_list ap); |
2906
2ec3ec904cd4
Try to provide a vsscanf() implementation, if the system does not have
jkeil
parents:
2780
diff
changeset
|
52 #else |
2ec3ec904cd4
Try to provide a vsscanf() implementation, if the system does not have
jkeil
parents:
2780
diff
changeset
|
53 /* system has no vsscanf. try to provide one */ |
2ec3ec904cd4
Try to provide a vsscanf() implementation, if the system does not have
jkeil
parents:
2780
diff
changeset
|
54 static int vsscanf( const char *str, const char *format, va_list ap) |
2ec3ec904cd4
Try to provide a vsscanf() implementation, if the system does not have
jkeil
parents:
2780
diff
changeset
|
55 { |
3465 | 56 long p1 = va_arg(ap, long); |
57 long p2 = va_arg(ap, long); | |
58 long p3 = va_arg(ap, long); | |
59 long p4 = va_arg(ap, long); | |
60 long p5 = va_arg(ap, long); | |
61 return sscanf(str, format, p1, p2, p3, p4, p5); | |
2906
2ec3ec904cd4
Try to provide a vsscanf() implementation, if the system does not have
jkeil
parents:
2780
diff
changeset
|
62 } |
2ec3ec904cd4
Try to provide a vsscanf() implementation, if the system does not have
jkeil
parents:
2780
diff
changeset
|
63 #endif |
1416 | 64 |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
65 char* def_path = WIN32_PATH; |
128 | 66 |
1923
40084ad62591
do_cpuid stored the results of the cpuid instruction in the wrong place
jkeil
parents:
1679
diff
changeset
|
67 static void do_cpuid(unsigned int ax, unsigned int *regs) |
128 | 68 { |
3465 | 69 __asm__ __volatile__ |
70 ( | |
71 "pushl %%ebx; pushl %%ecx; pushl %%edx;" | |
72 ".byte 0x0f, 0xa2;" | |
73 "movl %%eax, (%2);" | |
74 "movl %%ebx, 4(%2);" | |
75 "movl %%ecx, 8(%2);" | |
76 "movl %%edx, 12(%2);" | |
77 "popl %%edx; popl %%ecx; popl %%ebx;" | |
78 : "=a" (ax) | |
79 : "0" (ax), "S" (regs) | |
2069 | 80 ); |
128 | 81 } |
82 static unsigned int c_localcount_tsc() | |
1 | 83 { |
84 int a; | |
3465 | 85 __asm__ __volatile__ |
86 ( | |
87 "rdtsc\n\t" | |
88 :"=a"(a) | |
89 : | |
90 :"edx" | |
91 ); | |
1 | 92 return a; |
93 } | |
128 | 94 static void c_longcount_tsc(long long* z) |
1 | 95 { |
3465 | 96 __asm__ __volatile__ |
97 ( | |
98 "pushl %%ebx\n\t" | |
99 "movl %%eax, %%ebx\n\t" | |
100 "rdtsc\n\t" | |
101 "movl %%eax, 0(%%ebx)\n\t" | |
102 "movl %%edx, 4(%%ebx)\n\t" | |
103 "popl %%ebx\n\t" | |
104 ::"a"(z) | |
105 ); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
106 } |
128 | 107 static unsigned int c_localcount_notsc() |
1 | 108 { |
109 struct timeval tv; | |
110 unsigned limit=~0; | |
111 limit/=1000000; | |
112 gettimeofday(&tv, 0); | |
113 return limit*tv.tv_usec; | |
114 } | |
128 | 115 static void c_longcount_notsc(long long* z) |
1 | 116 { |
117 struct timeval tv; | |
118 unsigned long long result; | |
119 unsigned limit=~0; | |
120 if(!z)return; | |
121 limit/=1000000; | |
122 gettimeofday(&tv, 0); | |
123 result=tv.tv_sec; | |
124 result<<=32; | |
125 result+=limit*tv.tv_usec; | |
126 *z=result; | |
127 } | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
128 static unsigned int localcount_stub(void); |
2069 | 129 static void longcount_stub(long long*); |
128 | 130 static unsigned int (*localcount)()=localcount_stub; |
131 static void (*longcount)(long long*)=longcount_stub; | |
1 | 132 |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
133 static pthread_mutex_t memmut; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
134 |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
135 static unsigned int localcount_stub(void) |
128 | 136 { |
137 unsigned int regs[4]; | |
1923
40084ad62591
do_cpuid stored the results of the cpuid instruction in the wrong place
jkeil
parents:
1679
diff
changeset
|
138 do_cpuid(1, regs); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
139 if ((regs[3] & 0x00000010) != 0) |
128 | 140 { |
141 localcount=c_localcount_tsc; | |
142 longcount=c_longcount_tsc; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
143 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
144 else |
128 | 145 { |
3465 | 146 localcount=c_localcount_notsc; |
128 | 147 longcount=c_longcount_notsc; |
148 } | |
149 return localcount(); | |
150 } | |
151 static void longcount_stub(long long* z) | |
1 | 152 { |
128 | 153 unsigned int regs[4]; |
1923
40084ad62591
do_cpuid stored the results of the cpuid instruction in the wrong place
jkeil
parents:
1679
diff
changeset
|
154 do_cpuid(1, regs); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
155 if ((regs[3] & 0x00000010) != 0) |
128 | 156 { |
157 localcount=c_localcount_tsc; | |
158 longcount=c_longcount_tsc; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
159 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
160 else |
128 | 161 { |
3465 | 162 localcount=c_localcount_notsc; |
128 | 163 longcount=c_longcount_notsc; |
164 } | |
165 longcount(z); | |
166 } | |
2780 | 167 |
2069 | 168 int LOADER_DEBUG=1; // active only if compiled with -DDETAILED_OUT |
3128 | 169 //#define DETAILED_OUT |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
170 static inline void dbgprintf(char* fmt, ...) |
128 | 171 { |
235 | 172 #ifdef DETAILED_OUT |
128 | 173 if(LOADER_DEBUG) |
174 { | |
175 FILE* f; | |
176 va_list va; | |
3465 | 177 va_start(va, fmt); |
128 | 178 f=fopen("./log", "a"); |
3134 | 179 vprintf(fmt, va); |
3465 | 180 fflush(stdout); |
181 if(f) | |
128 | 182 { |
183 vfprintf(f, fmt, va); | |
184 fsync(fileno(f)); | |
3465 | 185 fclose(f); |
128 | 186 } |
187 va_end(va); | |
188 } | |
235 | 189 #endif |
3469 | 190 #if 0 |
191 // al3x: it break divx audio. btw it should be if(verbose>2){ ... } anyway... | |
192 // #ifdef MPLAYER | |
3435 | 193 #include "../mp_msg.h" |
194 { | |
195 char buf[1024]; | |
196 va_list va; | |
197 | |
198 va_start(va, fmt); | |
199 vsnprintf((char *)&buf[0], 1023, fmt, va); | |
200 mp_dbg(MSGT_WIN32, MSGL_DBG3, (char *)&buf[0]); | |
201 va_end(va); | |
202 } | |
203 #endif | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
204 } |
3128 | 205 |
206 | |
3465 | 207 char export_names[300][32]={ |
208 "name1", | |
209 //"name2", | |
210 //"name3" | |
1 | 211 }; |
212 //#define min(x,y) ((x)<(y)?(x):(y)) | |
213 | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
214 void destroy_event(void* event); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
215 |
3134 | 216 struct th_list_t; |
217 typedef struct th_list_t{ | |
218 int id; | |
219 void* thread; | |
220 struct th_list_t* next; | |
221 struct th_list_t* prev; | |
222 } th_list; | |
223 | |
224 | |
225 // have to be cleared by GARBAGE COLLECTOR | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
226 static unsigned char* heap=NULL; |
1 | 227 static int heap_counter=0; |
3134 | 228 static tls_t* g_tls=NULL; |
229 static th_list* list=NULL; | |
230 | |
2069 | 231 static void test_heap(void) |
1 | 232 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
233 int offset=0; |
1 | 234 if(heap==0) |
235 return; | |
236 while(offset<heap_counter) | |
237 { | |
238 if(*(int*)(heap+offset)!=0x433476) | |
239 { | |
240 printf("Heap corruption at address %d\n", offset); | |
241 return; | |
242 } | |
243 offset+=8+*(int*)(heap+offset+4); | |
244 } | |
245 for(;offset<min(offset+1000, 20000000); offset++) | |
246 if(heap[offset]!=0xCC) | |
3465 | 247 { |
248 printf("Free heap corruption at address %d\n", offset); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
249 } |
1 | 250 } |
251 #undef MEMORY_DEBUG | |
252 | |
253 #ifdef MEMORY_DEBUG | |
254 | |
255 void* my_mreq(int size, int to_zero) | |
256 { | |
257 static int test=0; | |
258 test++; | |
259 if(test%10==0)printf("Memory: %d bytes allocated\n", heap_counter); | |
3465 | 260 // test_heap(); |
1 | 261 if(heap==NULL) |
262 { | |
263 heap=malloc(20000000); | |
264 memset(heap, 0xCC,20000000); | |
265 } | |
266 if(heap==0) | |
267 { | |
268 printf("No enough memory\n"); | |
269 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
270 } |
1 | 271 if(heap_counter+size>20000000) |
272 { | |
273 printf("No enough memory\n"); | |
274 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
275 } |
1 | 276 *(int*)(heap+heap_counter)=0x433476; |
277 heap_counter+=4; | |
278 *(int*)(heap+heap_counter)=size; | |
279 heap_counter+=4; | |
280 printf("Allocated %d bytes of memory: sys %d, user %d-%d\n", size, heap_counter-8, heap_counter, heap_counter+size); | |
281 if(to_zero) | |
3465 | 282 memset(heap+heap_counter, 0, size); |
1543 | 283 else |
2139 | 284 memset(heap+heap_counter, 0xcc, size); // make crash reproducable |
1 | 285 heap_counter+=size; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
286 return heap+heap_counter-size; |
1 | 287 } |
2069 | 288 int my_release(char* memory) |
1 | 289 { |
3465 | 290 // test_heap(); |
1 | 291 if(memory==NULL) |
292 { | |
293 printf("ERROR: free(0)\n"); | |
294 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
295 } |
1 | 296 if(*(int*)(memory-8)!=0x433476) |
297 { | |
298 printf("MEMORY CORRUPTION !!!!!!!!!!!!!!!!!!!\n"); | |
299 return 0; | |
300 } | |
301 printf("Freed %d bytes of memory\n", *(int*)(memory-4)); | |
3465 | 302 // memset(memory-8, *(int*)(memory-4), 0xCC); |
1 | 303 return 0; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
304 } |
1 | 305 |
306 #else | |
128 | 307 #define GARBAGE |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
308 typedef struct alloc_header_t alloc_header; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
309 struct alloc_header_t |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
310 { |
3465 | 311 // let's keep allocated data 16 byte aligned |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
312 alloc_header* prev; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
313 alloc_header* next; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
314 long deadbeef; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
315 long size; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
316 long type; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
317 long reserved1; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
318 long reserved2; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
319 long reserved3; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
320 }; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
321 |
128 | 322 #ifdef GARBAGE |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
323 static alloc_header* last_alloc = NULL; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
324 static int alccnt = 0; |
128 | 325 #endif |
326 | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
327 #define AREATYPE_CLIENT 0 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
328 #define AREATYPE_EVENT 1 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
329 #define AREATYPE_MUTEX 2 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
330 #define AREATYPE_COND 3 |
3134 | 331 #define AREATYPE_CRITSECT 4 |
332 | |
333 /* -- critical sections -- */ | |
334 struct CRITSECT | |
335 { | |
336 pthread_t id; | |
337 pthread_mutex_t mutex; | |
338 int locked; | |
339 }; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
340 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
341 void* mreq_private(int size, int to_zero, int type); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
342 void* mreq_private(int size, int to_zero, int type) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
343 { |
3465 | 344 int nsize = size + sizeof(alloc_header); |
345 alloc_header* header = malloc(nsize); | |
346 if (!header) | |
347 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
348 if (to_zero) |
3465 | 349 memset(header, 0, nsize); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
350 #ifdef GARBAGE |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
351 if (!last_alloc) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
352 { |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
353 pthread_mutex_init(&memmut, NULL); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
354 pthread_mutex_lock(&memmut); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
355 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
356 else |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
357 { |
3465 | 358 pthread_mutex_lock(&memmut); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
359 last_alloc->next = header; /* set next */ |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
360 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
361 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
362 header->prev = last_alloc; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
363 header->next = 0; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
364 last_alloc = header; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
365 alccnt++; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
366 pthread_mutex_unlock(&memmut); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
367 #endif |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
368 header->deadbeef = 0xdeadbeef; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
369 header->size = size; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
370 header->type = type; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
371 |
3128 | 372 //if (alccnt < 40000) printf("MY_REQ: %p\t%d t:%d (cnt:%d)\n", header, size, type, alccnt); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
373 return header + 1; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
374 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
375 |
597 | 376 int my_release(void* memory) |
1 | 377 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
378 alloc_header* header = (alloc_header*) memory - 1; |
128 | 379 #ifdef GARBAGE |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
380 alloc_header* prevmem; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
381 alloc_header* nextmem; |
3134 | 382 |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
383 if (memory == 0) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
384 return 0; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
385 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
386 if (header->deadbeef != 0xdeadbeef) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
387 { |
3128 | 388 printf("FATAL releasing corrupted memory! %p 0x%lx (%d)\n", header, header->deadbeef, alccnt); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
389 return 0; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
390 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
391 |
3128 | 392 pthread_mutex_lock(&memmut); |
393 | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
394 switch(header->type) |
128 | 395 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
396 case AREATYPE_EVENT: |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
397 destroy_event(memory); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
398 break; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
399 case AREATYPE_COND: |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
400 pthread_cond_destroy((pthread_cond_t*)memory); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
401 break; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
402 case AREATYPE_MUTEX: |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
403 pthread_mutex_destroy((pthread_mutex_t*)memory); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
404 break; |
3134 | 405 case AREATYPE_CRITSECT: |
406 pthread_mutex_destroy(&((struct CRITSECT*)memory)->mutex); | |
407 break; | |
408 default: | |
409 //memset(memory, 0xcc, header->size); | |
128 | 410 } |
3128 | 411 |
3465 | 412 header->deadbeef = 0; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
413 prevmem = header->prev; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
414 nextmem = header->next; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
415 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
416 if (prevmem) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
417 prevmem->next = nextmem; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
418 if (nextmem) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
419 nextmem->prev = prevmem; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
420 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
421 if (header == last_alloc) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
422 last_alloc = prevmem; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
423 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
424 alccnt--; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
425 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
426 if (last_alloc) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
427 pthread_mutex_unlock(&memmut); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
428 else |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
429 pthread_mutex_destroy(&memmut); |
3465 | 430 |
3128 | 431 //if (alccnt < 40000) printf("MY_RELEASE: %p\t%ld (%d)\n", header, header->size, alccnt); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
432 #else |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
433 if (memory == 0) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
434 return 0; |
128 | 435 #endif |
3465 | 436 //memset(header + 1, 0xcc, header->size); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
437 free(header); |
1 | 438 return 0; |
439 } | |
440 #endif | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
441 |
3465 | 442 inline void* my_mreq(int size, int to_zero) |
443 { | |
444 return mreq_private(size, to_zero, AREATYPE_CLIENT); | |
445 } | |
446 | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
447 static inline int my_size(void* memory) |
2069 | 448 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
449 return ((alloc_header*)memory)[-1].size; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
450 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
451 |
3465 | 452 static void* my_realloc(void* memory, int size) |
1 | 453 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
454 void *ans = memory; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
455 int osize = my_size(memory); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
456 if (memory == NULL) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
457 return my_mreq(size, 0); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
458 if (osize < size) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
459 { |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
460 ans = my_mreq(size, 0); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
461 memcpy(ans, memory, osize); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
462 my_release(memory); |
2069 | 463 } |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
464 return ans; |
2069 | 465 } |
1 | 466 |
3465 | 467 /* |
468 * | |
469 * WINE API - native implementation for several win32 libraries | |
470 * | |
471 */ | |
472 | |
473 static int WINAPI ext_unknown() | |
1 | 474 { |
475 printf("Unknown func called\n"); | |
476 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
477 } |
3465 | 478 |
479 static int WINAPI expIsBadWritePtr(void* ptr, unsigned int count) | |
1 | 480 { |
3465 | 481 int result = (count == 0 || ptr != 0) ? 0 : 1; |
128 | 482 dbgprintf("IsBadWritePtr(0x%x, 0x%x) => %d\n", ptr, count, result); |
483 return result; | |
1 | 484 } |
3465 | 485 static int WINAPI expIsBadReadPtr(void* ptr, unsigned int count) |
1 | 486 { |
3465 | 487 int result = (count == 0 || ptr != 0) ? 0 : 1; |
128 | 488 dbgprintf("IsBadReadPtr(0x%x, 0x%x) => %d\n", ptr, count, result); |
489 return result; | |
1 | 490 } |
3465 | 491 static int WINAPI expDisableThreadLibraryCalls(int module) |
1 | 492 { |
128 | 493 dbgprintf("DisableThreadLibraryCalls(0x%x) => 0\n", module); |
1 | 494 return 0; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
495 } |
3465 | 496 |
497 static HMODULE WINAPI expGetDriverModuleHandle(DRVR* pdrv) | |
1 | 498 { |
2069 | 499 HMODULE result; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
500 if (pdrv==NULL) |
2069 | 501 result=0; |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
502 else |
3465 | 503 result=pdrv->hDriverModule; |
2069 | 504 dbgprintf("GetDriverModuleHandle(%p) => %p\n", pdrv, result); |
128 | 505 return result; |
1 | 506 } |
507 | |
2069 | 508 #define MODULE_HANDLE_kernel32 ((HMODULE)0x120) |
509 | |
3465 | 510 static HMODULE WINAPI expGetModuleHandleA(const char* name) |
1 | 511 { |
3465 | 512 WINE_MODREF* wm; |
513 HMODULE result; | |
514 if(!name) | |
515 result=0; | |
516 else | |
517 { | |
518 wm=MODULE_FindModule(name); | |
519 if(wm==0)result=0; | |
128 | 520 else |
3465 | 521 result=(HMODULE)(wm->module); |
522 } | |
523 if(!result) | |
524 { | |
3672
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
525 if(name && strcasecmp(name, "kernel32")==0) |
3465 | 526 result=MODULE_HANDLE_kernel32; |
527 } | |
528 dbgprintf("GetModuleHandleA('%s') => 0x%x\n", name, result); | |
529 return result; | |
1 | 530 } |
128 | 531 |
1 | 532 |
3465 | 533 static void* WINAPI expCreateThread(void* pSecAttr, long dwStackSize, |
534 void* lpStartAddress, void* lpParameter, | |
535 long dwFlags, long* dwThreadId) | |
1 | 536 { |
537 pthread_t *pth; | |
3465 | 538 // printf("CreateThread:"); |
1 | 539 pth=my_mreq(sizeof(pthread_t), 0); |
540 pthread_create(pth, NULL, (void*(*)(void*))lpStartAddress, lpParameter); | |
541 if(dwFlags) | |
128 | 542 printf( "WARNING: CreateThread flags not supported\n"); |
1 | 543 if(dwThreadId) |
544 *dwThreadId=(long)pth; | |
545 if(list==NULL) | |
546 { | |
547 list=my_mreq(sizeof(th_list), 1); | |
548 list->next=list->prev=NULL; | |
549 } | |
550 else | |
551 { | |
552 list->next=my_mreq(sizeof(th_list), 0); | |
553 list->next->prev=list; | |
554 list->next->next=NULL; | |
555 list=list->next; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
556 } |
1 | 557 list->thread=pth; |
128 | 558 dbgprintf("CreateThread(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) => 0x%x\n", |
3465 | 559 pSecAttr, dwStackSize, lpStartAddress, lpParameter, dwFlags, dwThreadId, pth); |
1 | 560 return pth; |
561 } | |
562 | |
563 struct mutex_list_t; | |
564 | |
565 struct mutex_list_t | |
566 { | |
128 | 567 char type; |
1 | 568 pthread_mutex_t *pm; |
128 | 569 pthread_cond_t *pc; |
570 char state; | |
571 char reset; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
572 char name[128]; |
128 | 573 int semaphore; |
1 | 574 struct mutex_list_t* next; |
575 struct mutex_list_t* prev; | |
576 }; | |
577 typedef struct mutex_list_t mutex_list; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
578 static mutex_list* mlist=NULL; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
579 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
580 void destroy_event(void* event) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
581 { |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
582 mutex_list* pp=mlist; |
3465 | 583 // printf("garbage collector: destroy_event(%x)\n", event); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
584 while(pp) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
585 { |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
586 if(pp==(mutex_list*)event) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
587 { |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
588 if(pp->next) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
589 pp->next->prev=pp->prev; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
590 if(pp->prev) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
591 pp->prev->next=pp->next; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
592 if(mlist==(mutex_list*)event) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
593 mlist=mlist->prev; |
3465 | 594 /* |
595 pp=mlist; | |
596 while(pp) | |
597 { | |
598 printf("%x => ", pp); | |
599 pp=pp->prev; | |
600 } | |
601 printf("0\n"); | |
602 */ | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
603 return; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
604 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
605 pp=pp->prev; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
606 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
607 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
608 |
3465 | 609 static void* WINAPI expCreateEventA(void* pSecAttr, char bManualReset, |
610 char bInitialState, const char* name) | |
1 | 611 { |
612 pthread_mutex_t *pm; | |
128 | 613 pthread_cond_t *pc; |
3465 | 614 /* |
615 mutex_list* pp; | |
616 pp=mlist; | |
617 while(pp) | |
618 { | |
619 printf("%x => ", pp); | |
620 pp=pp->prev; | |
621 } | |
622 printf("0\n"); | |
623 */ | |
1 | 624 if(mlist!=NULL) |
625 { | |
626 mutex_list* pp=mlist; | |
627 if(name!=NULL) | |
3465 | 628 do |
1 | 629 { |
128 | 630 if((strcmp(pp->name, name)==0) && (pp->type==0)) |
631 { | |
632 dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, 0x%x='%s') => 0x%x\n", | |
3465 | 633 pSecAttr, bManualReset, bInitialState, name, name, pp->pm); |
1 | 634 return pp->pm; |
128 | 635 } |
2069 | 636 }while((pp=pp->prev) != NULL); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
637 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
638 pm=mreq_private(sizeof(pthread_mutex_t), 0, AREATYPE_MUTEX); |
1 | 639 pthread_mutex_init(pm, NULL); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
640 pc=mreq_private(sizeof(pthread_cond_t), 0, AREATYPE_COND); |
128 | 641 pthread_cond_init(pc, NULL); |
1 | 642 if(mlist==NULL) |
643 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
644 mlist=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT); |
1 | 645 mlist->next=mlist->prev=NULL; |
646 } | |
647 else | |
648 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
649 mlist->next=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT); |
128 | 650 mlist->next->prev=mlist; |
1 | 651 mlist->next->next=NULL; |
652 mlist=mlist->next; | |
653 } | |
128 | 654 mlist->type=0; /* Type Event */ |
1 | 655 mlist->pm=pm; |
128 | 656 mlist->pc=pc; |
657 mlist->state=bInitialState; | |
658 mlist->reset=bManualReset; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
659 if(name) |
3465 | 660 strncpy(mlist->name, name, 127); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
661 else |
1 | 662 mlist->name[0]=0; |
663 if(pm==NULL) | |
664 dbgprintf("ERROR::: CreateEventA failure\n"); | |
3465 | 665 /* |
666 if(bInitialState) | |
667 pthread_mutex_lock(pm); | |
668 */ | |
128 | 669 if(name) |
3465 | 670 dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, 0x%x='%s') => 0x%x\n", |
671 pSecAttr, bManualReset, bInitialState, name, name, mlist); | |
128 | 672 else |
3465 | 673 dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, NULL) => 0x%x\n", |
674 pSecAttr, bManualReset, bInitialState, mlist); | |
128 | 675 return mlist; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
676 } |
1 | 677 |
3465 | 678 static void* WINAPI expSetEvent(void* event) |
1 | 679 { |
128 | 680 mutex_list *ml = (mutex_list *)event; |
681 dbgprintf("SetEvent(%x) => 0x1\n", event); | |
682 pthread_mutex_lock(ml->pm); | |
683 if (ml->state == 0) { | |
684 ml->state = 1; | |
685 pthread_cond_signal(ml->pc); | |
686 } | |
687 pthread_mutex_unlock(ml->pm); | |
688 | |
689 return (void *)1; | |
1 | 690 } |
3465 | 691 static void* WINAPI expResetEvent(void* event) |
1 | 692 { |
128 | 693 mutex_list *ml = (mutex_list *)event; |
694 dbgprintf("ResetEvent(0x%x) => 0x1\n", event); | |
695 pthread_mutex_lock(ml->pm); | |
696 ml->state = 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
697 pthread_mutex_unlock(ml->pm); |
128 | 698 |
699 return (void *)1; | |
1 | 700 } |
701 | |
3465 | 702 static void* WINAPI expWaitForSingleObject(void* object, int duration) |
1 | 703 { |
128 | 704 mutex_list *ml = (mutex_list *)object; |
2069 | 705 // FIXME FIXME FIXME - this value is sometime unititialize !!! |
706 int ret = WAIT_FAILED; | |
128 | 707 mutex_list* pp=mlist; |
2779 | 708 if(object == (void*)0xcfcf9898) |
709 { | |
3465 | 710 /** |
711 From GetCurrentThread() documentation: | |
712 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. | |
713 | |
714 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. | |
715 | |
716 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. | |
717 **/ | |
2779 | 718 dbgprintf("WaitForSingleObject(thread_handle) called\n"); |
3128 | 719 return (void*)WAIT_FAILED; |
2779 | 720 } |
2069 | 721 dbgprintf("WaitForSingleObject(0x%x, duration %d) =>\n",object, duration); |
722 | |
718 | 723 // loop below was slightly fixed - its used just for checking if |
724 // this object really exists in our list | |
725 if (!ml) | |
3465 | 726 return (void*) ret; |
718 | 727 while (pp && (pp->pm != ml->pm)) |
2069 | 728 pp = pp->prev; |
718 | 729 if (!pp) { |
2069 | 730 dbgprintf("WaitForSingleObject: NotFound\n"); |
731 return (void*)ret; | |
718 | 732 } |
128 | 733 |
734 pthread_mutex_lock(ml->pm); | |
735 | |
736 switch(ml->type) { | |
3465 | 737 case 0: /* Event */ |
128 | 738 if (duration == 0) { /* Check Only */ |
3465 | 739 if (ml->state == 1) ret = WAIT_FAILED; |
740 else ret = WAIT_OBJECT_0; | |
128 | 741 } |
742 if (duration == -1) { /* INFINITE */ | |
3465 | 743 if (ml->state == 0) |
744 pthread_cond_wait(ml->pc,ml->pm); | |
745 if (ml->reset) | |
746 ml->state = 0; | |
747 ret = WAIT_OBJECT_0; | |
128 | 748 } |
749 if (duration > 0) { /* Timed Wait */ | |
3465 | 750 struct timespec abstime; |
751 struct timeval now; | |
752 gettimeofday(&now, 0); | |
753 abstime.tv_sec = now.tv_sec + (now.tv_usec+duration)/1000000; | |
754 abstime.tv_nsec = ((now.tv_usec+duration)%1000000)*1000; | |
755 if (ml->state == 0) | |
756 ret=pthread_cond_timedwait(ml->pc,ml->pm,&abstime); | |
757 if (ret == ETIMEDOUT) ret = WAIT_TIMEOUT; | |
758 else ret = WAIT_OBJECT_0; | |
759 if (ml->reset) | |
760 ml->state = 0; | |
128 | 761 } |
3465 | 762 break; |
763 case 1: /* Semaphore */ | |
764 if (duration == 0) { | |
765 if(ml->semaphore==0) ret = WAIT_FAILED; | |
766 else { | |
767 ml->semaphore++; | |
768 ret = WAIT_OBJECT_0; | |
769 } | |
770 } | |
128 | 771 if (duration == -1) { |
3465 | 772 if (ml->semaphore==0) |
773 pthread_cond_wait(ml->pc,ml->pm); | |
774 ml->semaphore--; | |
128 | 775 } |
3465 | 776 break; |
128 | 777 } |
778 pthread_mutex_unlock(ml->pm); | |
779 | |
780 dbgprintf("WaitForSingleObject(0x%x, %d): 0x%x => 0x%x \n",object,duration,ml,ret); | |
781 return (void *)ret; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
782 } |
1 | 783 |
784 static BYTE PF[64] = {0,}; | |
785 | |
3465 | 786 static WIN_BOOL WINAPI expIsProcessorFeaturePresent(DWORD v) |
128 | 787 { |
788 WIN_BOOL result; | |
789 if(v>63)result=0; | |
790 else result=PF[v]; | |
791 dbgprintf("IsProcessorFeaturePresent(0x%x) => 0x%x\n", v, result); | |
792 return result; | |
793 } | |
794 | |
795 static void DumpSystemInfo(const SYSTEM_INFO* si) | |
796 { | |
797 dbgprintf(" Processor architecture %d\n", si->u.s.wProcessorArchitecture); | |
798 dbgprintf(" Page size: %d\n", si->dwPageSize); | |
799 dbgprintf(" Minimum app address: %d\n", si->lpMinimumApplicationAddress); | |
800 dbgprintf(" Maximum app address: %d\n", si->lpMaximumApplicationAddress); | |
801 dbgprintf(" Active processor mask: 0x%x\n", si->dwActiveProcessorMask); | |
802 dbgprintf(" Number of processors: %d\n", si->dwNumberOfProcessors); | |
803 dbgprintf(" Processor type: 0x%x\n", si->dwProcessorType); | |
804 dbgprintf(" Allocation granularity: 0x%x\n", si->dwAllocationGranularity); | |
805 dbgprintf(" Processor level: 0x%x\n", si->wProcessorLevel); | |
806 dbgprintf(" Processor revision: 0x%x\n", si->wProcessorRevision); | |
807 } | |
808 | |
3465 | 809 static void WINAPI expGetSystemInfo(SYSTEM_INFO* si) |
1 | 810 { |
3465 | 811 /* FIXME: better values for the two entries below... */ |
812 static int cache = 0; | |
813 static SYSTEM_INFO cachedsi; | |
814 unsigned int regs[4]; | |
815 dbgprintf("GetSystemInfo(%p) =>\n", si); | |
816 | |
817 if (cache) { | |
818 memcpy(si,&cachedsi,sizeof(*si)); | |
819 DumpSystemInfo(si); | |
820 return; | |
821 } | |
822 memset(PF,0,sizeof(PF)); | |
823 | |
824 cachedsi.u.s.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL; | |
825 cachedsi.dwPageSize = getpagesize(); | |
826 | |
827 /* FIXME: better values for the two entries below... */ | |
828 cachedsi.lpMinimumApplicationAddress = (void *)0x00000000; | |
829 cachedsi.lpMaximumApplicationAddress = (void *)0x7FFFFFFF; | |
830 cachedsi.dwActiveProcessorMask = 1; | |
831 cachedsi.dwNumberOfProcessors = 1; | |
832 cachedsi.dwProcessorType = PROCESSOR_INTEL_386; | |
833 cachedsi.dwAllocationGranularity = 0x10000; | |
834 cachedsi.wProcessorLevel = 5; /* pentium */ | |
835 cachedsi.wProcessorRevision = 0x0101; | |
836 | |
837 #ifdef MPLAYER | |
838 /* mplayer's way to detect PF's */ | |
839 { | |
840 #include "../cpudetect.h" | |
841 extern CpuCaps gCpuCaps; | |
842 | |
843 if (gCpuCaps.hasMMX) | |
844 PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE; | |
845 if (gCpuCaps.hasSSE) | |
846 PF[PF_XMMI_INSTRUCTIONS_AVAILABLE] = TRUE; | |
847 if (gCpuCaps.has3DNow) | |
848 PF[PF_AMD3D_INSTRUCTIONS_AVAILABLE] = TRUE; | |
3404 | 849 |
850 switch(gCpuCaps.cpuType) | |
851 { | |
852 case CPUTYPE_I686: | |
853 case CPUTYPE_I586: | |
854 cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
855 cachedsi.wProcessorLevel = 5; | |
856 break; | |
857 case CPUTYPE_I486: | |
858 cachedsi.dwProcessorType = PROCESSOR_INTEL_486; | |
859 cachedsi.wProcessorLevel = 4; | |
860 break; | |
861 case CPUTYPE_I386: | |
862 default: | |
863 cachedsi.dwProcessorType = PROCESSOR_INTEL_386; | |
864 cachedsi.wProcessorLevel = 3; | |
865 break; | |
866 } | |
867 cachedsi.wProcessorRevision = gCpuCaps.cpuStepping; | |
868 cachedsi.dwNumberOfProcessors = 1; /* hardcoded */ | |
3465 | 869 |
870 } | |
3405 | 871 #endif |
3128 | 872 |
3404 | 873 /* disable cpuid based detection (mplayer's cpudetect.c does this - see above) */ |
3465 | 874 #ifndef MPLAYER |
1038
b36fb1ae4b53
applied solaris8/netbsd/other fixes patch by J«ärgen Keil <jk@tools.de>
arpi_esp
parents:
718
diff
changeset
|
875 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__svr4__) |
3465 | 876 do_cpuid(1, regs); |
877 switch ((regs[0] >> 8) & 0xf) { // cpu family | |
878 case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386; | |
879 cachedsi.wProcessorLevel= 3; | |
880 break; | |
881 case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486; | |
882 cachedsi.wProcessorLevel= 4; | |
883 break; | |
884 case 5: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
885 cachedsi.wProcessorLevel= 5; | |
886 break; | |
887 case 6: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
888 cachedsi.wProcessorLevel= 5; | |
889 break; | |
890 default:cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
891 cachedsi.wProcessorLevel= 5; | |
892 break; | |
893 } | |
894 cachedsi.wProcessorRevision = regs[0] & 0xf; // stepping | |
895 if (regs[3] & (1 << 8)) | |
896 PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE; | |
897 if (regs[3] & (1 << 23)) | |
898 PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE; | |
899 if (regs[3] & (1 << 25)) | |
900 PF[PF_XMMI_INSTRUCTIONS_AVAILABLE] = TRUE; | |
901 if (regs[3] & (1 << 31)) | |
902 PF[PF_AMD3D_INSTRUCTIONS_AVAILABLE] = TRUE; | |
903 cachedsi.dwNumberOfProcessors=1; | |
3404 | 904 #endif |
3465 | 905 #endif /* MPLAYER */ |
3404 | 906 |
3405 | 907 /* MPlayer: linux detection enabled (based on proc/cpuinfo) for checking |
908 fdiv_bug and fpu emulation flags -- alex/MPlayer */ | |
3404 | 909 #ifdef __linux__ |
3465 | 910 { |
1 | 911 char buf[20]; |
912 char line[200]; | |
913 FILE *f = fopen ("/proc/cpuinfo", "r"); | |
914 | |
915 if (!f) | |
3465 | 916 return; |
1 | 917 while (fgets(line,200,f)!=NULL) { |
3465 | 918 char *s,*value; |
919 | |
920 /* NOTE: the ':' is the only character we can rely on */ | |
921 if (!(value = strchr(line,':'))) | |
922 continue; | |
923 /* terminate the valuename */ | |
924 *value++ = '\0'; | |
925 /* skip any leading spaces */ | |
926 while (*value==' ') value++; | |
927 if ((s=strchr(value,'\n'))) | |
928 *s='\0'; | |
929 | |
930 /* 2.1 method */ | |
931 if (!lstrncmpiA(line, "cpu family",strlen("cpu family"))) { | |
932 if (isdigit (value[0])) { | |
933 switch (value[0] - '0') { | |
934 case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386; | |
935 cachedsi.wProcessorLevel= 3; | |
936 break; | |
937 case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486; | |
938 cachedsi.wProcessorLevel= 4; | |
939 break; | |
940 case 5: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
941 cachedsi.wProcessorLevel= 5; | |
942 break; | |
943 case 6: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
944 cachedsi.wProcessorLevel= 5; | |
945 break; | |
946 default:cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
947 cachedsi.wProcessorLevel= 5; | |
948 break; | |
949 } | |
1 | 950 } |
3465 | 951 /* set the CPU type of the current processor */ |
952 sprintf(buf,"CPU %ld",cachedsi.dwProcessorType); | |
953 continue; | |
954 } | |
955 /* old 2.0 method */ | |
956 if (!lstrncmpiA(line, "cpu",strlen("cpu"))) { | |
957 if ( isdigit (value[0]) && value[1] == '8' && | |
958 value[2] == '6' && value[3] == 0 | |
959 ) { | |
960 switch (value[0] - '0') { | |
961 case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386; | |
962 cachedsi.wProcessorLevel= 3; | |
963 break; | |
964 case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486; | |
965 cachedsi.wProcessorLevel= 4; | |
966 break; | |
967 case 5: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
968 cachedsi.wProcessorLevel= 5; | |
969 break; | |
970 case 6: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
971 cachedsi.wProcessorLevel= 5; | |
972 break; | |
973 default:cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM; | |
974 cachedsi.wProcessorLevel= 5; | |
975 break; | |
976 } | |
1 | 977 } |
3465 | 978 /* set the CPU type of the current processor */ |
979 sprintf(buf,"CPU %ld",cachedsi.dwProcessorType); | |
980 continue; | |
981 } | |
982 if (!lstrncmpiA(line,"fdiv_bug",strlen("fdiv_bug"))) { | |
983 if (!lstrncmpiA(value,"yes",3)) | |
984 PF[PF_FLOATING_POINT_PRECISION_ERRATA] = TRUE; | |
985 | |
986 continue; | |
987 } | |
988 if (!lstrncmpiA(line,"fpu",strlen("fpu"))) { | |
989 if (!lstrncmpiA(value,"no",2)) | |
990 PF[PF_FLOATING_POINT_EMULATED] = TRUE; | |
991 | |
992 continue; | |
993 } | |
994 if (!lstrncmpiA(line,"processor",strlen("processor"))) { | |
995 /* processor number counts up...*/ | |
996 int x; | |
997 | |
998 if (sscanf(value,"%d",&x)) | |
999 if (x+1>cachedsi.dwNumberOfProcessors) | |
1000 cachedsi.dwNumberOfProcessors=x+1; | |
1001 | |
1002 /* Create a new processor subkey on a multiprocessor | |
1003 * system | |
1004 */ | |
1005 sprintf(buf,"%d",x); | |
1006 } | |
1007 if (!lstrncmpiA(line,"stepping",strlen("stepping"))) { | |
1008 int x; | |
1009 | |
1010 if (sscanf(value,"%d",&x)) | |
1011 cachedsi.wProcessorRevision = x; | |
1012 } | |
1013 if | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1014 ( (!lstrncmpiA(line,"flags",strlen("flags"))) |
3465 | 1015 || (!lstrncmpiA(line,"features",strlen("features"))) ) |
1016 { | |
1017 if (strstr(value,"cx8")) | |
1018 PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE; | |
1019 if (strstr(value,"mmx")) | |
1020 PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE; | |
1021 if (strstr(value,"tsc")) | |
1022 PF[PF_RDTSC_INSTRUCTION_AVAILABLE] = TRUE; | |
1023 if (strstr(value,"xmm")) | |
1024 PF[PF_XMMI_INSTRUCTIONS_AVAILABLE] = TRUE; | |
1025 if (strstr(value,"3dnow")) | |
1026 PF[PF_AMD3D_INSTRUCTIONS_AVAILABLE] = TRUE; | |
1027 } | |
1 | 1028 } |
1029 fclose (f); | |
3465 | 1030 /* |
1031 * ad hoc fix for smp machines. | |
1032 * some problems on WaitForSingleObject,CreateEvent,SetEvent | |
1033 * CreateThread ...etc.. | |
1034 * | |
1035 */ | |
1036 cachedsi.dwNumberOfProcessors=1; | |
1037 } | |
3404 | 1038 #endif /* __linux__ */ |
3465 | 1039 cache = 1; |
1040 memcpy(si,&cachedsi,sizeof(*si)); | |
1041 DumpSystemInfo(si); | |
1 | 1042 } |
1043 | |
3465 | 1044 static long WINAPI expGetVersion() |
1 | 1045 { |
128 | 1046 dbgprintf("GetVersion() => 0xC0000004\n"); |
1047 return 0xC0000004;//Windows 95 | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1048 } |
1 | 1049 |
3465 | 1050 static HANDLE WINAPI expHeapCreate(long flags, long init_size, long max_size) |
1 | 1051 { |
3465 | 1052 // printf("HeapCreate:"); |
128 | 1053 HANDLE result; |
1 | 1054 if(init_size==0) |
3465 | 1055 result=(HANDLE)my_mreq(0x110000, 0); |
1 | 1056 else |
3465 | 1057 result=(HANDLE)my_mreq((init_size + 0xfff) & 0x7ffff000 , 0); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1058 dbgprintf("HeapCreate(flags 0x%x, initial size %d, maximum size %d) => 0x%x\n", flags, init_size, max_size, result); |
128 | 1059 return result; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1060 } |
3128 | 1061 |
1062 // this is another dirty hack | |
3465 | 1063 // VP31 is releasing one allocated Heap chunk twice |
3128 | 1064 // we will silently ignore this second call... |
1065 static void* heapfreehack = 0; | |
1066 static int heapfreehackshown = 0; | |
3465 | 1067 //extern void trapbug(void); |
1068 static void* WINAPI expHeapAlloc(HANDLE heap, int flags, int size) | |
1 | 1069 { |
1070 void* z; | |
3465 | 1071 /** |
1072 Morgan's m3jpeg32.dll v. 2.0 encoder expects that request for | |
1073 HeapAlloc returns area larger than size argument :-/ | |
1074 | |
1075 actually according to M$ Doc HeapCreate size should be rounded | |
1076 to page boundaries thus we should simulate this | |
1077 **/ | |
1078 //if (size == 22276) trapbug(); | |
1079 z=my_mreq((size + 0xfff) & 0x7ffff000, (flags & HEAP_ZERO_MEMORY)); | |
1 | 1080 if(z==0) |
1081 printf("HeapAlloc failure\n"); | |
3465 | 1082 dbgprintf("HeapAlloc(heap 0x%x, flags 0x%x, size %d) => 0x%x\n", heap, flags, size, z); |
3128 | 1083 heapfreehack = 0; // reset |
1 | 1084 return z; |
1085 } | |
3465 | 1086 static long WINAPI expHeapDestroy(void* heap) |
1 | 1087 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1088 dbgprintf("HeapDestroy(heap 0x%x) => 1\n", heap); |
1 | 1089 my_release(heap); |
1090 return 1; | |
1091 } | |
1092 | |
3465 | 1093 static long WINAPI expHeapFree(int arg1, int arg2, void* ptr) |
1 | 1094 { |
128 | 1095 dbgprintf("HeapFree(0x%x, 0x%x, pointer 0x%x) => 1\n", arg1, arg2, ptr); |
3134 | 1096 if (heapfreehack != ptr && ptr != (void*)0xffffffff) |
3128 | 1097 my_release(ptr); |
1098 else | |
1099 { | |
3465 | 1100 if (!heapfreehackshown++) |
3128 | 1101 printf("Info: HeapFree deallocating same memory twice! (%p)\n", ptr); |
1102 } | |
1103 heapfreehack = ptr; | |
1 | 1104 return 1; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1105 } |
3465 | 1106 static long WINAPI expHeapSize(int heap, int flags, void* pointer) |
1 | 1107 { |
128 | 1108 long result=my_size(pointer); |
1109 dbgprintf("HeapSize(heap 0x%x, flags 0x%x, pointer 0x%x) => %d\n", heap, flags, pointer, result); | |
1110 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1111 } |
3465 | 1112 static void* WINAPI expHeapReAlloc(HANDLE heap,int flags,void *lpMem,int size) |
2069 | 1113 { |
3465 | 1114 long orgsize = my_size(lpMem); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1115 dbgprintf("HeapReAlloc() Size %ld org %d\n",orgsize,size); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1116 return my_realloc(lpMem, size); |
2069 | 1117 } |
3465 | 1118 static long WINAPI expGetProcessHeap(void) |
1 | 1119 { |
128 | 1120 dbgprintf("GetProcessHeap() => 1\n"); |
1 | 1121 return 1; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1122 } |
3465 | 1123 static void* WINAPI expVirtualAlloc(void* v1, long v2, long v3, long v4) |
1 | 1124 { |
3465 | 1125 void* z = VirtualAlloc(v1, v2, v3, v4); |
1 | 1126 if(z==0) |
1127 printf("VirtualAlloc failure\n"); | |
128 | 1128 dbgprintf("VirtualAlloc(0x%x, %d, %d, %d) => 0x%x \n",v1,v2,v3,v4, z); |
1 | 1129 return z; |
1130 } | |
3465 | 1131 static int WINAPI expVirtualFree(void* v1, int v2, int v3) |
1 | 1132 { |
3465 | 1133 int result = VirtualFree(v1,v2,v3); |
128 | 1134 dbgprintf("VirtualFree(0x%x, %d, %d) => %d\n",v1,v2,v3, result); |
1135 return result; | |
3128 | 1136 } |
2579 | 1137 |
1138 /* we're building a table of critical sections. cs_win pointer uses the DLL | |
3465 | 1139 cs_unix is the real structure, we're using cs_win only to identifying cs_unix */ |
2579 | 1140 struct critsecs_list_t |
1141 { | |
1142 CRITICAL_SECTION *cs_win; | |
1143 struct CRITSECT *cs_unix; | |
1144 }; | |
1145 | |
3457 | 1146 /* 'NEWTYPE' is working with VIVO and 3ivX dll (no more segfaults) -- alex */ |
3465 | 1147 #undef CRITSECS_NEWTYPE |
1148 //#define CRITSECS_NEWTYPE 1 | |
3128 | 1149 |
1150 #ifdef CRITSECS_NEWTYPE | |
2579 | 1151 #define CRITSECS_LIST_MAX 20 |
1152 static struct critsecs_list_t critsecs_list[CRITSECS_LIST_MAX]; | |
1153 | |
3465 | 1154 static int critsecs_get_pos(CRITICAL_SECTION *cs_win) |
2579 | 1155 { |
1156 int i; | |
3128 | 1157 |
2579 | 1158 for (i=0; i < CRITSECS_LIST_MAX; i++) |
1159 if (critsecs_list[i].cs_win == cs_win) | |
1160 return(i); | |
1161 return(-1); | |
1162 } | |
1163 | |
3465 | 1164 static int critsecs_get_unused(void) |
2579 | 1165 { |
1166 int i; | |
3128 | 1167 |
2579 | 1168 for (i=0; i < CRITSECS_LIST_MAX; i++) |
1169 if (critsecs_list[i].cs_win == NULL) | |
1170 return(i); | |
1171 return(-1); | |
1172 } | |
1173 | |
1174 #if 0 | |
1175 #define critsecs_get_unix(cs_win) (critsecs_list[critsecs_get_pos(cs_win)].cs_win) | |
1176 #else | |
1177 struct CRITSECT *critsecs_get_unix(CRITICAL_SECTION *cs_win) | |
1178 { | |
1179 int i; | |
3128 | 1180 |
2579 | 1181 for (i=0; i < CRITSECS_LIST_MAX; i++) |
2670 | 1182 if (critsecs_list[i].cs_win == cs_win && critsecs_list[i].cs_unix) |
2579 | 1183 return(critsecs_list[i].cs_unix); |
1184 return(NULL); | |
1185 } | |
1186 #endif | |
3128 | 1187 #endif |
2579 | 1188 |
3465 | 1189 static void WINAPI expInitializeCriticalSection(CRITICAL_SECTION* c) |
1 | 1190 { |
128 | 1191 dbgprintf("InitializeCriticalSection(0x%x)\n", c); |
3465 | 1192 /* if(sizeof(pthread_mutex_t)>sizeof(CRITICAL_SECTION)) |
1193 { | |
1194 printf(" ERROR:::: sizeof(pthread_mutex_t) is %d, expected <=%d!\n", | |
1195 sizeof(pthread_mutex_t), sizeof(CRITICAL_SECTION)); | |
1196 return; | |
1197 }*/ | |
1198 /* pthread_mutex_init((pthread_mutex_t*)c, NULL); */ | |
2579 | 1199 #ifdef CRITSECS_NEWTYPE |
1200 { | |
3465 | 1201 struct CRITSECT *cs; |
1202 int i = critsecs_get_unused(); | |
1203 | |
1204 if (i < 0) | |
1205 { | |
1206 printf("InitializeCriticalSection(%p) - no more space in list\n", c); | |
1207 return; | |
1208 } | |
1209 printf("got unused space at %d\n", i); | |
1210 cs = expmalloc(sizeof(struct CRITSECT)); | |
1211 if (!cs) | |
1212 { | |
1213 printf("InitializeCriticalSection(%p) - out of memory\n", c); | |
1214 return; | |
1215 } | |
1216 pthread_mutex_init(&cs->mutex, NULL); | |
1217 cs->locked = 0; | |
1218 critsecs_list[i].cs_win = c; | |
1219 critsecs_list[i].cs_unix = cs; | |
1220 dbgprintf("InitializeCriticalSection -> itemno=%d, cs_win=%p, cs_unix=%p\n", | |
1221 i, c, cs); | |
2579 | 1222 } |
3465 | 1223 #else |
2670 | 1224 { |
3465 | 1225 struct CRITSECT* cs = mreq_private(sizeof(struct CRITSECT), 0, AREATYPE_CRITSECT); |
1226 pthread_mutex_init(&cs->mutex, NULL); | |
1227 cs->locked=0; | |
1228 *(void**)c = cs; | |
2670 | 1229 } |
2579 | 1230 #endif |
1 | 1231 return; |
2579 | 1232 } |
1233 | |
3465 | 1234 static void WINAPI expEnterCriticalSection(CRITICAL_SECTION* c) |
1 | 1235 { |
2579 | 1236 #ifdef CRITSECS_NEWTYPE |
1237 struct CRITSECT* cs = critsecs_get_unix(c); | |
1238 #else | |
128 | 1239 struct CRITSECT* cs=*(struct CRITSECT**)c; |
2579 | 1240 #endif |
128 | 1241 dbgprintf("EnterCriticalSection(0x%x)\n",c); |
2069 | 1242 if (!cs) |
1243 { | |
3465 | 1244 printf("entered uninitialized critisec!\n"); |
2069 | 1245 expInitializeCriticalSection(c); |
2579 | 1246 #ifdef CRITSECS_NEWTYPE |
1247 cs=critsecs_get_unix(c); | |
1248 #else | |
2069 | 1249 cs=*(struct CRITSECT**)c; |
2579 | 1250 #endif |
2069 | 1251 printf("Win32 Warning: Accessed uninitialized Critical Section (%p)!\n", c); |
1252 } | |
1 | 1253 if(cs->locked) |
1254 if(cs->id==pthread_self()) | |
1255 return; | |
1256 pthread_mutex_lock(&(cs->mutex)); | |
1257 cs->locked=1; | |
1258 cs->id=pthread_self(); | |
1259 return; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1260 } |
3465 | 1261 static void WINAPI expLeaveCriticalSection(CRITICAL_SECTION* c) |
1 | 1262 { |
2579 | 1263 #ifdef CRITSECS_NEWTYPE |
1264 struct CRITSECT* cs = critsecs_get_unix(c); | |
1265 #else | |
128 | 1266 struct CRITSECT* cs=*(struct CRITSECT**)c; |
2579 | 1267 #endif |
3465 | 1268 // struct CRITSECT* cs=(struct CRITSECT*)c; |
128 | 1269 dbgprintf("LeaveCriticalSection(0x%x)\n",c); |
2069 | 1270 if (!cs) |
1271 { | |
1272 printf("Win32 Warning: Leaving noninitialized Critical Section %p!!\n", c); | |
1273 return; | |
1274 } | |
1 | 1275 cs->locked=0; |
1276 pthread_mutex_unlock(&(cs->mutex)); | |
1277 return; | |
1278 } | |
3465 | 1279 static void WINAPI expDeleteCriticalSection(CRITICAL_SECTION *c) |
1 | 1280 { |
2579 | 1281 #ifdef CRITSECS_NEWTYPE |
1282 struct CRITSECT* cs = critsecs_get_unix(c); | |
1283 #else | |
128 | 1284 struct CRITSECT* cs=*(struct CRITSECT**)c; |
2579 | 1285 #endif |
3465 | 1286 // struct CRITSECT* cs=(struct CRITSECT*)c; |
128 | 1287 dbgprintf("DeleteCriticalSection(0x%x)\n",c); |
3465 | 1288 |
1289 #ifndef GARBAGE | |
128 | 1290 pthread_mutex_destroy(&(cs->mutex)); |
3465 | 1291 // released by GarbageCollector in my_relase otherwise |
1292 #endif | |
1293 my_release(cs); | |
2579 | 1294 #ifdef CRITSECS_NEWTYPE |
1295 { | |
3465 | 1296 int i = critsecs_get_pos(c); |
1297 | |
1298 if (i < 0) | |
1299 { | |
1300 printf("DeleteCriticalSection(%p) error (critsec not found)\n", c); | |
1301 return; | |
1302 } | |
1303 | |
1304 critsecs_list[i].cs_win = NULL; | |
1305 expfree(critsecs_list[i].cs_unix); | |
1306 critsecs_list[i].cs_unix = NULL; | |
1307 dbgprintf("DeleteCriticalSection -> itemno=%d\n", i); | |
2579 | 1308 } |
1309 #endif | |
1 | 1310 return; |
1311 } | |
3465 | 1312 static int WINAPI expGetCurrentThreadId() |
1 | 1313 { |
128 | 1314 dbgprintf("GetCurrentThreadId() => %d\n", getpid()); |
1315 return getpid(); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1316 } |
3465 | 1317 static int WINAPI expGetCurrentProcess() |
128 | 1318 { |
1319 dbgprintf("GetCurrentProcess() => %d\n", getpid()); | |
1 | 1320 return getpid(); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1321 } |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1322 |
2779 | 1323 extern void* fs_seg; |
1324 | |
3128 | 1325 #if 0 |
1326 // this version is required for Quicktime codecs (.qtx/.qts) to work. | |
1327 // (they assume some pointers at FS: segment) | |
1328 | |
2779 | 1329 //static int tls_count; |
1330 static int tls_use_map[64]; | |
3465 | 1331 static int WINAPI expTlsAlloc() |
2779 | 1332 { |
1333 int i; | |
1334 for(i=0; i<64; i++) | |
1335 if(tls_use_map[i]==0) | |
1336 { | |
1337 tls_use_map[i]=1; | |
1338 return i; | |
1339 } | |
1340 return -1; | |
1341 } | |
1342 | |
3465 | 1343 static int WINAPI expTlsSetValue(void idx, void* value) |
2779 | 1344 { |
3465 | 1345 int index = (int) idx; |
2779 | 1346 if((index<0) || (index>64)) |
1347 return 0; | |
1348 *(void**)((char*)fs_seg+0x88+4*index) = value; | |
1349 return 1; | |
1350 } | |
1351 | |
3465 | 1352 static void* WINAPI expTlsGetValue(int idx) |
2779 | 1353 { |
3465 | 1354 int index = (int) idx; |
2779 | 1355 if((index<0) || (index>64)) |
1356 return 0; | |
1357 return *(void**)((char*)fs_seg+0x88+index); | |
1358 } | |
1359 | |
3465 | 1360 static int WINAPI expTlsFree(int idx) |
2779 | 1361 { |
3465 | 1362 int index = (int) idx; |
2779 | 1363 if((index<0) || (index>64)) |
1364 return 0; | |
1365 tls_use_map[index]=0; | |
1366 return 1; | |
1367 } | |
1368 | |
1369 #else | |
2069 | 1370 struct tls_s { |
1 | 1371 void* value; |
1372 int used; | |
1373 struct tls_s* prev; | |
1374 struct tls_s* next; | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1375 }; |
2069 | 1376 |
3465 | 1377 static void* WINAPI expTlsAlloc() |
1 | 1378 { |
1379 if(g_tls==NULL) | |
1380 { | |
1381 g_tls=my_mreq(sizeof(tls_t), 0); | |
1382 g_tls->next=g_tls->prev=NULL; | |
1383 } | |
1384 else | |
1385 { | |
1386 g_tls->next=my_mreq(sizeof(tls_t), 0); | |
1387 g_tls->next->prev=g_tls; | |
1388 g_tls->next->next=NULL; | |
1389 g_tls=g_tls->next; | |
1390 } | |
128 | 1391 dbgprintf("TlsAlloc() => 0x%x\n", g_tls); |
2670 | 1392 if (g_tls) |
1393 g_tls->value=0; /* XXX For Divx.dll */ | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1394 return g_tls; |
1 | 1395 } |
1396 | |
3465 | 1397 static int WINAPI expTlsSetValue(void* idx, void* value) |
1 | 1398 { |
3465 | 1399 tls_t* index = (tls_t*) idx; |
128 | 1400 int result; |
1 | 1401 if(index==0) |
128 | 1402 result=0; |
1403 else | |
1404 { | |
1405 index->value=value; | |
1406 result=1; | |
1407 } | |
1408 dbgprintf("TlsSetValue(index 0x%x, value 0x%x) => %d \n", index, value, result ); | |
1409 return result; | |
1 | 1410 } |
3465 | 1411 static void* WINAPI expTlsGetValue(void* idx) |
1 | 1412 { |
3465 | 1413 tls_t* index = (tls_t*) idx; |
128 | 1414 void* result; |
1 | 1415 if(index==0) |
128 | 1416 result=0; |
1417 else | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1418 result=index->value; |
128 | 1419 dbgprintf("TlsGetValue(index 0x%x) => 0x%x\n", index, result); |
1420 return result; | |
1 | 1421 } |
3465 | 1422 static int WINAPI expTlsFree(void* idx) |
1 | 1423 { |
3465 | 1424 tls_t* index = (tls_t*) idx; |
128 | 1425 int result; |
1 | 1426 if(index==0) |
128 | 1427 result=0; |
1428 else | |
1429 { | |
1430 if(index->next) | |
1431 index->next->prev=index->prev; | |
1432 if(index->prev) | |
3465 | 1433 index->prev->next=index->next; |
128 | 1434 my_release((void*)index); |
1435 result=1; | |
1436 } | |
1437 dbgprintf("TlsFree(index 0x%x) => %d\n", index, result); | |
1438 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1439 } |
2779 | 1440 #endif |
1441 | |
3465 | 1442 static void* WINAPI expLocalAlloc(int flags, int size) |
1 | 1443 { |
3465 | 1444 void* z = my_mreq(size, (flags & GMEM_ZEROINIT)); |
1445 if (z == 0) | |
1 | 1446 printf("LocalAlloc() failed\n"); |
128 | 1447 dbgprintf("LocalAlloc(%d, flags 0x%x) => 0x%x\n", size, flags, z); |
1 | 1448 return z; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1449 } |
2069 | 1450 |
3465 | 1451 static void* WINAPI expLocalReAlloc(int handle,int size, int flags) |
2069 | 1452 { |
3465 | 1453 void *newpointer; |
1454 int oldsize; | |
1455 | |
1456 newpointer=NULL; | |
1457 if (flags & LMEM_MODIFY) { | |
1458 dbgprintf("LocalReAlloc MODIFY\n"); | |
1459 return (void *)handle; | |
1460 } | |
1461 oldsize = my_size((void *)handle); | |
1462 newpointer = my_realloc((void *)handle,size); | |
1463 dbgprintf("LocalReAlloc(%x %d(old %d), flags 0x%x) => 0x%x\n", handle,size,oldsize, flags,newpointer); | |
1464 | |
1465 return newpointer; | |
2069 | 1466 } |
1467 | |
3465 | 1468 static void* WINAPI expLocalLock(void* z) |
1 | 1469 { |
128 | 1470 dbgprintf("LocalLock(0x%x) => 0x%x\n", z, z); |
1 | 1471 return z; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1472 } |
128 | 1473 |
3465 | 1474 static void* WINAPI expGlobalAlloc(int flags, int size) |
1 | 1475 { |
1476 void* z; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1477 dbgprintf("GlobalAlloc(%d, flags 0x%X)\n", size, flags); |
3465 | 1478 |
1479 z=my_mreq(size, (flags & GMEM_ZEROINIT)); | |
1480 //z=calloc(size, 1); | |
1481 //z=malloc(size); | |
1 | 1482 if(z==0) |
128 | 1483 printf("GlobalAlloc() failed\n"); |
1484 dbgprintf("GlobalAlloc(%d, flags 0x%x) => 0x%x\n", size, flags, z); | |
1 | 1485 return z; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1486 } |
3465 | 1487 static void* WINAPI expGlobalLock(void* z) |
1 | 1488 { |
128 | 1489 dbgprintf("GlobalLock(0x%x) => 0x%x\n", z, z); |
1 | 1490 return z; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1491 } |
3128 | 1492 // pvmjpg20 - but doesn't work anyway |
3465 | 1493 static int WINAPI expGlobalSize(void* amem) |
3128 | 1494 { |
1495 int size = 100000; | |
1496 #ifdef GARBAGE | |
1497 alloc_header* header = last_alloc; | |
1498 alloc_header* mem = (alloc_header*) amem - 1; | |
1499 if (amem == 0) | |
3465 | 1500 return 0; |
3128 | 1501 pthread_mutex_lock(&memmut); |
1502 while (header) | |
1503 { | |
3465 | 1504 if (header->deadbeef != 0xdeadbeef) |
1505 { | |
1506 printf("FATAL found corrupted memory! %p 0x%lx (%d)\n", header, header->deadbeef, alccnt); | |
1507 break; | |
1508 } | |
1509 | |
1510 if (header == mem) | |
1511 { | |
1512 size = header->size; | |
1513 break; | |
1514 } | |
1515 | |
1516 header = header->prev; | |
3128 | 1517 } |
1518 pthread_mutex_unlock(&memmut); | |
1519 #endif | |
1520 | |
1521 dbgprintf("GlobalSize(0x%x)\n", amem); | |
1522 return size; | |
1523 } | |
3465 | 1524 static int WINAPI expLoadStringA(long instance, long id, void* buf, long size) |
1 | 1525 { |
128 | 1526 int result=LoadStringA(instance, id, buf, size); |
3465 | 1527 // if(buf) |
128 | 1528 dbgprintf("LoadStringA(instance 0x%x, id 0x%x, buffer 0x%x, size %d) => %d ( %s )\n", |
3465 | 1529 instance, id, buf, size, result, buf); |
1530 // else | |
1531 // dbgprintf("LoadStringA(instance 0x%x, id 0x%x, buffer 0x%x, size %d) => %d\n", | |
1532 // instance, id, buf, size, result); | |
128 | 1533 return result; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1534 } |
1 | 1535 |
3465 | 1536 static long WINAPI expMultiByteToWideChar(long v1, long v2, char* s1, long siz1, short* s2, int siz2) |
1 | 1537 { |
1538 #warning FIXME | |
128 | 1539 int i; |
1540 int result; | |
1 | 1541 if(s2==0) |
3465 | 1542 result=1; |
128 | 1543 else |
1544 { | |
3465 | 1545 if(siz1>siz2/2)siz1=siz2/2; |
1546 for(i=1; i<=siz1; i++) | |
1547 { | |
1548 *s2=*s1; | |
1549 if(!*s1)break; | |
1550 s2++; | |
1551 s1++; | |
1552 } | |
1553 result=i; | |
128 | 1554 } |
1555 if(s1) | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1556 dbgprintf("MultiByteToWideChar(codepage %d, flags 0x%x, string 0x%x='%s'," |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1557 "size %d, dest buffer 0x%x, dest size %d) => %d\n", |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1558 v1, v2, s1, s1, siz1, s2, siz2, result); |
128 | 1559 else |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1560 dbgprintf("MultiByteToWideChar(codepage %d, flags 0x%x, string NULL," |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1561 "size %d, dest buffer 0x%x, dest size %d) =>\n", |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1562 v1, v2, siz1, s2, siz2, result); |
128 | 1563 return result; |
1564 } | |
1565 static void wch_print(const short* str) | |
1566 { | |
1567 dbgprintf(" src: "); | |
1568 while(*str)dbgprintf("%c", *str++); | |
1569 dbgprintf("\n"); | |
1 | 1570 } |
3465 | 1571 static long WINAPI expWideCharToMultiByte(long v1, long v2, short* s1, long siz1, |
1572 char* s2, int siz2, char* c3, int* siz3) | |
1 | 1573 { |
1574 int result; | |
128 | 1575 dbgprintf("WideCharToMultiByte(codepage %d, flags 0x%x, src 0x%x, src size %d, " |
3465 | 1576 "dest 0x%x, dest size %d, defch 0x%x, used_defch 0x%x)", v1, v2, s1, siz1, s2, siz2, c3, siz3); |
1 | 1577 result=WideCharToMultiByte(v1, v2, s1, siz1, s2, siz2, c3, siz3); |
1578 dbgprintf("=> %d\n", result); | |
2069 | 1579 //if(s1)wch_print(s1); |
128 | 1580 if(s2)dbgprintf(" dest: %s\n", s2); |
1 | 1581 return result; |
1582 } | |
3465 | 1583 static long WINAPI expGetVersionExA(OSVERSIONINFOA* c) |
1 | 1584 { |
128 | 1585 dbgprintf("GetVersionExA(0x%x) => 1\n"); |
1586 c->dwOSVersionInfoSize=sizeof(*c); | |
1 | 1587 c->dwMajorVersion=4; |
128 | 1588 c->dwMinorVersion=0; |
1589 c->dwBuildNumber=0x4000457; | |
2069 | 1590 #if 0 |
1591 // leave it here for testing win9x-only codecs | |
1 | 1592 c->dwPlatformId=VER_PLATFORM_WIN32_WINDOWS; |
128 | 1593 strcpy(c->szCSDVersion, " B"); |
2069 | 1594 #else |
1595 c->dwPlatformId=VER_PLATFORM_WIN32_NT; // let's not make DLL assume that it can read CR* registers | |
1596 strcpy(c->szCSDVersion, "Service Pack 3"); | |
1597 #endif | |
128 | 1598 dbgprintf(" Major version: 4\n Minor version: 0\n Build number: 0x4000457\n" |
3465 | 1599 " Platform Id: VER_PLATFORM_WIN32_NT\n Version string: 'Service Pack 3'\n"); |
1 | 1600 return 1; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1601 } |
3465 | 1602 static HANDLE WINAPI expCreateSemaphoreA(char* v1, long init_count, |
1603 long max_count, char* name) | |
1 | 1604 { |
128 | 1605 pthread_mutex_t *pm; |
1606 pthread_cond_t *pc; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1607 mutex_list* pp; |
3465 | 1608 /* |
1609 printf("CreateSemaphoreA(%p = %s)\n", name, (name ? name : "<null>")); | |
1610 pp=mlist; | |
1611 while(pp) | |
1612 { | |
1613 printf("%p => ", pp); | |
1614 pp=pp->prev; | |
1615 } | |
1616 printf("0\n"); | |
1617 */ | |
128 | 1618 if(mlist!=NULL) |
1 | 1619 { |
128 | 1620 mutex_list* pp=mlist; |
1621 if(name!=NULL) | |
3465 | 1622 do |
128 | 1623 { |
1624 if((strcmp(pp->name, name)==0) && (pp->type==1)) | |
1625 { | |
3465 | 1626 dbgprintf("CreateSemaphoreA(0x%x, init_count %d, max_count %d, name 0x%x='%s') => 0x%x\n", |
1627 v1, init_count, max_count, name, name, mlist); | |
128 | 1628 return (HANDLE)mlist; |
1629 } | |
2069 | 1630 }while((pp=pp->prev) != NULL); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1631 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1632 pm=mreq_private(sizeof(pthread_mutex_t), 0, AREATYPE_MUTEX); |
128 | 1633 pthread_mutex_init(pm, NULL); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1634 pc=mreq_private(sizeof(pthread_cond_t), 0, AREATYPE_COND); |
128 | 1635 pthread_cond_init(pc, NULL); |
1636 if(mlist==NULL) | |
1637 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1638 mlist=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT); |
128 | 1639 mlist->next=mlist->prev=NULL; |
1640 } | |
1641 else | |
1 | 1642 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1643 mlist->next=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT); |
128 | 1644 mlist->next->prev=mlist; |
1645 mlist->next->next=NULL; | |
1646 mlist=mlist->next; | |
3465 | 1647 // printf("new semaphore %p\n", mlist); |
1 | 1648 } |
128 | 1649 mlist->type=1; /* Type Semaphore */ |
1650 mlist->pm=pm; | |
1651 mlist->pc=pc; | |
1652 mlist->state=0; | |
1653 mlist->reset=0; | |
1654 mlist->semaphore=init_count; | |
1655 if(name!=NULL) | |
3465 | 1656 strncpy(mlist->name, name, 64); |
128 | 1657 else |
1658 mlist->name[0]=0; | |
1659 if(pm==NULL) | |
1660 dbgprintf("ERROR::: CreateSemaphoreA failure\n"); | |
1661 if(name) | |
3465 | 1662 dbgprintf("CreateSemaphoreA(0x%x, init_count %d, max_count %d, name 0x%x='%s') => 0x%x\n", |
1663 v1, init_count, max_count, name, name, mlist); | |
128 | 1664 else |
3465 | 1665 dbgprintf("CreateSemaphoreA(0x%x, init_count %d, max_count %d, name 0) => 0x%x\n", |
1666 v1, init_count, max_count, mlist); | |
128 | 1667 return (HANDLE)mlist; |
1 | 1668 } |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1669 |
3465 | 1670 static long WINAPI expReleaseSemaphore(long hsem, long increment, long* prev_count) |
1 | 1671 { |
3465 | 1672 // The state of a semaphore object is signaled when its count |
1673 // is greater than zero and nonsignaled when its count is equal to zero | |
1674 // Each time a waiting thread is released because of the semaphore's signaled | |
1675 // state, the count of the semaphore is decreased by one. | |
128 | 1676 mutex_list *ml = (mutex_list *)hsem; |
1 | 1677 |
128 | 1678 pthread_mutex_lock(ml->pm); |
1679 if (prev_count != 0) *prev_count = ml->semaphore; | |
1680 if (ml->semaphore == 0) pthread_cond_signal(ml->pc); | |
1681 ml->semaphore += increment; | |
1682 pthread_mutex_unlock(ml->pm); | |
1683 dbgprintf("ReleaseSemaphore(semaphore 0x%x, increment %d, prev_count 0x%x) => 1\n", | |
3465 | 1684 hsem, increment, prev_count); |
128 | 1685 return 1; |
1 | 1686 } |
1687 | |
1688 | |
3465 | 1689 static long WINAPI expRegOpenKeyExA(long key, const char* subkey, long reserved, long access, int* newkey) |
1 | 1690 { |
128 | 1691 long result=RegOpenKeyExA(key, subkey, reserved, access, newkey); |
1692 dbgprintf("RegOpenKeyExA(key 0x%x, subkey %s, reserved %d, access 0x%x, pnewkey 0x%x) => %d\n", | |
3465 | 1693 key, subkey, reserved, access, newkey, result); |
128 | 1694 if(newkey)dbgprintf(" New key: 0x%x\n", *newkey); |
1695 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1696 } |
3465 | 1697 static long WINAPI expRegCloseKey(long key) |
1 | 1698 { |
128 | 1699 long result=RegCloseKey(key); |
1700 dbgprintf("RegCloseKey(0x%x) => %d\n", key, result); | |
1701 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1702 } |
3465 | 1703 static long WINAPI expRegQueryValueExA(long key, const char* value, int* reserved, int* type, int* data, int* count) |
1 | 1704 { |
128 | 1705 long result=RegQueryValueExA(key, value, reserved, type, data, count); |
1706 dbgprintf("RegQueryValueExA(key 0x%x, value %s, reserved 0x%x, data 0x%x, count 0x%x)" | |
3465 | 1707 " => 0x%x\n", key, value, reserved, data, count, result); |
128 | 1708 if(data && count)dbgprintf(" read %d bytes: '%s'\n", *count, data); |
1709 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1710 } |
3465 | 1711 static long WINAPI expRegCreateKeyExA(long key, const char* name, long reserved, |
1712 void* classs, long options, long security, | |
1713 void* sec_attr, int* newkey, int* status) | |
1 | 1714 { |
128 | 1715 long result=RegCreateKeyExA(key, name, reserved, classs, options, security, sec_attr, newkey, status); |
1716 dbgprintf("RegCreateKeyExA(key 0x%x, name 0x%x='%s', reserved=0x%x," | |
3465 | 1717 " 0x%x, 0x%x, 0x%x, newkey=0x%x, status=0x%x) => %d\n", |
1718 key, name, name, reserved, classs, options, security, sec_attr, newkey, status, result); | |
128 | 1719 if(!result && newkey) dbgprintf(" New key: 0x%x\n", *newkey); |
1720 if(!result && status) dbgprintf(" New key status: 0x%x\n", *status); | |
1721 return result; | |
1 | 1722 } |
3465 | 1723 static long WINAPI expRegSetValueExA(long key, const char* name, long v1, long v2, void* data, long size) |
1 | 1724 { |
128 | 1725 long result=RegSetValueExA(key, name, v1, v2, data, size); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1726 dbgprintf("RegSetValueExA(key 0x%x, name '%s', 0x%x, 0x%x, data 0x%x -> 0x%x '%s', size=%d) => %d", |
3465 | 1727 key, name, v1, v2, data, *(int*)data, data, size, result); |
128 | 1728 return result; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1729 } |
1 | 1730 |
3465 | 1731 static long WINAPI expRegOpenKeyA (long hKey, LPCSTR lpSubKey, int* phkResult) |
3134 | 1732 { |
128 | 1733 long result=RegOpenKeyExA(hKey, lpSubKey, 0, 0, phkResult); |
1734 dbgprintf("RegOpenKeyExA(key 0x%x, subkey '%s', 0x%x) => %d\n", | |
3465 | 1735 hKey, lpSubKey, phkResult, result); |
128 | 1736 if(!result && phkResult) dbgprintf(" New key: 0x%x\n", *phkResult); |
1737 return result; | |
1 | 1738 } |
1739 | |
3465 | 1740 static DWORD WINAPI expRegEnumValueA(HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count, |
1741 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count) | |
2069 | 1742 { |
1743 return RegEnumValueA(hkey, index, value, val_count, | |
1744 reserved, type, data, count); | |
1745 } | |
1746 | |
3465 | 1747 static DWORD WINAPI expRegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcbName, |
1748 LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcbClass, | |
1749 LPFILETIME lpftLastWriteTime) | |
1750 { | |
1751 return RegEnumKeyExA(hKey, dwIndex, lpName, lpcbName, lpReserved, lpClass, | |
1752 lpcbClass, lpftLastWriteTime); | |
1753 } | |
1754 | |
1755 static long WINAPI expQueryPerformanceCounter(long long* z) | |
1 | 1756 { |
1757 longcount(z); | |
128 | 1758 dbgprintf("QueryPerformanceCounter(0x%x) => 1 ( %Ld )\n", z, *z); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1759 return 1; |
1 | 1760 } |
1761 | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1762 /* |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1763 * return CPU clock (in kHz), using linux's /proc filesystem (/proc/cpuinfo) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1764 */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1765 static double linux_cpuinfo_freq() |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1766 { |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1767 double freq=-1; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1768 FILE *f; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1769 char line[200]; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1770 char *s,*value; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1771 |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1772 f = fopen ("/proc/cpuinfo", "r"); |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1773 if (f != NULL) { |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1774 while (fgets(line,sizeof(line),f)!=NULL) { |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1775 /* NOTE: the ':' is the only character we can rely on */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1776 if (!(value = strchr(line,':'))) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1777 continue; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1778 /* terminate the valuename */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1779 *value++ = '\0'; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1780 /* skip any leading spaces */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1781 while (*value==' ') value++; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1782 if ((s=strchr(value,'\n'))) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1783 *s='\0'; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1784 |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1785 if (!strncasecmp(line, "cpu MHz",strlen("cpu MHz")) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1786 && sscanf(value, "%lf", &freq) == 1) { |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1787 freq*=1000; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1788 break; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1789 } |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1790 } |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1791 fclose(f); |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1792 } |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1793 return freq; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1794 } |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1795 |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1796 |
3465 | 1797 static double solaris_kstat_freq() |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1798 { |
1679
73c8f54305b1
Add a few ifdefs, so that the code compiles on old solaris releases (2.6 and 7)
jkeil
parents:
1543
diff
changeset
|
1799 #if defined(HAVE_LIBKSTAT) && defined(KSTAT_DATA_INT32) |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1800 /* |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1801 * try to extract the CPU speed from the solaris kernel's kstat data |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1802 */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1803 kstat_ctl_t *kc; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1804 kstat_t *ksp; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1805 kstat_named_t *kdata; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1806 int mhz = 0; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1807 |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1808 kc = kstat_open(); |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1809 if (kc != NULL) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1810 { |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1811 ksp = kstat_lookup(kc, "cpu_info", 0, "cpu_info0"); |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1812 |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1813 /* kstat found and name/value pairs? */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1814 if (ksp != NULL && ksp->ks_type == KSTAT_TYPE_NAMED) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1815 { |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1816 /* read the kstat data from the kernel */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1817 if (kstat_read(kc, ksp, NULL) != -1) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1818 { |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1819 /* |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1820 * lookup desired "clock_MHz" entry, check the expected |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1821 * data type |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1822 */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1823 kdata = (kstat_named_t *)kstat_data_lookup(ksp, "clock_MHz"); |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1824 if (kdata != NULL && kdata->data_type == KSTAT_DATA_INT32) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1825 mhz = kdata->value.i32; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1826 } |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1827 } |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1828 kstat_close(kc); |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1829 } |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1830 |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1831 if (mhz > 0) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1832 return mhz * 1000.; |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1833 #endif /* HAVE_LIBKSTAT */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1834 return -1; // kstat stuff is not available, CPU freq is unknown |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1835 } |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1836 |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1837 /* |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1838 * Measure CPU freq using the pentium's time stamp counter register (TSC) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1839 */ |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1840 static double tsc_freq() |
1 | 1841 { |
128 | 1842 static double ofreq=0.0; |
1843 int i; | |
1 | 1844 int x,y; |
128 | 1845 i=time(NULL); |
1846 if (ofreq != 0.0) return ofreq; | |
1 | 1847 while(i==time(NULL)); |
1848 x=localcount(); | |
1849 i++; | |
1850 while(i==time(NULL)); | |
1851 y=localcount(); | |
128 | 1852 ofreq = (double)(y-x)/1000.; |
1853 return ofreq; | |
1 | 1854 } |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1855 |
1 | 1856 static double CPU_Freq() |
1857 { | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1858 double freq; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1859 |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1860 if ((freq = linux_cpuinfo_freq()) > 0) |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1861 return freq; |
1 | 1862 |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1863 if ((freq = solaris_kstat_freq()) > 0) |
1 | 1864 return freq; |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
1096
diff
changeset
|
1865 |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1866 return tsc_freq(); |
1 | 1867 } |
1868 | |
3465 | 1869 static long WINAPI expQueryPerformanceFrequency(long long* z) |
1 | 1870 { |
1871 *z=(long long)CPU_Freq(); | |
128 | 1872 dbgprintf("QueryPerformanceFrequency(0x%x) => 1 ( %Ld )\n", z, *z); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1873 return 1; |
1 | 1874 } |
3465 | 1875 static long WINAPI exptimeGetTime() |
1 | 1876 { |
1877 struct timeval t; | |
128 | 1878 long result; |
1 | 1879 gettimeofday(&t, 0); |
128 | 1880 result=1000*t.tv_sec+t.tv_usec/1000; |
1881 dbgprintf("timeGetTime() => %d\n", result); | |
1882 return result; | |
1 | 1883 } |
3465 | 1884 static void* WINAPI expLocalHandle(void* v) |
1 | 1885 { |
128 | 1886 dbgprintf("LocalHandle(0x%x) => 0x%x\n", v, v); |
1 | 1887 return v; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1888 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1889 |
3465 | 1890 static void* WINAPI expGlobalHandle(void* v) |
1 | 1891 { |
128 | 1892 dbgprintf("GlobalHandle(0x%x) => 0x%x\n", v, v); |
1 | 1893 return v; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1894 } |
3465 | 1895 static int WINAPI expGlobalUnlock(void* v) |
1 | 1896 { |
128 | 1897 dbgprintf("GlobalUnlock(0x%x) => 1\n", v); |
1 | 1898 return 1; |
1899 } | |
3465 | 1900 static void* WINAPI expGlobalFree(void* v) |
1 | 1901 { |
128 | 1902 dbgprintf("GlobalFree(0x%x) => 0\n", v); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1903 my_release(v); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1904 //free(v); |
1 | 1905 return 0; |
128 | 1906 } |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1907 |
3465 | 1908 static void* WINAPI expGlobalReAlloc(void* v, int size, int flags) |
128 | 1909 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1910 void* result=my_realloc(v, size); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1911 //void* result=realloc(v, size); |
128 | 1912 dbgprintf("GlobalReAlloc(0x%x, size %d, flags 0x%x) => 0x%x\n", v,size,flags,result); |
1913 return result; | |
1914 } | |
1 | 1915 |
3465 | 1916 static int WINAPI expLocalUnlock(void* v) |
1 | 1917 { |
128 | 1918 dbgprintf("LocalUnlock(0x%x) => 1\n", v); |
1 | 1919 return 1; |
1920 } | |
3465 | 1921 // |
1922 static void* WINAPI expLocalFree(void* v) | |
1 | 1923 { |
128 | 1924 dbgprintf("LocalFree(0x%x) => 0\n", v); |
1 | 1925 my_release(v); |
1926 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1927 } |
3465 | 1928 static HRSRC WINAPI expFindResourceA(HMODULE module, char* name, char* type) |
1 | 1929 { |
3465 | 1930 HRSRC result; |
1931 | |
1932 result=FindResourceA(module, name, type); | |
1933 dbgprintf("FindResourceA(module 0x%x, name 0x%x(%s), type 0x%x(%s)) => 0x%x\n", module, HIWORD(name) ? name : "UNICODE", HIWORD(type) ? type : "UNICODE", result); | |
128 | 1934 return result; |
1 | 1935 } |
3465 | 1936 |
128 | 1937 extern HRSRC WINAPI LoadResource(HMODULE, HRSRC); |
3465 | 1938 static HGLOBAL WINAPI expLoadResource(HMODULE module, HRSRC res) |
1 | 1939 { |
128 | 1940 HGLOBAL result=LoadResource(module, res); |
1941 dbgprintf("LoadResource(module 0x%x, resource 0x%x) => 0x%x\n", module, res, result); | |
1942 return result; | |
1 | 1943 } |
3465 | 1944 static void* WINAPI expLockResource(long res) |
1 | 1945 { |
128 | 1946 void* result=LockResource(res); |
1947 dbgprintf("LockResource(0x%x) => 0x%x\n", res, result); | |
1948 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1949 } |
3465 | 1950 static int WINAPI expFreeResource(long res) |
1 | 1951 { |
128 | 1952 int result=FreeResource(res); |
1953 dbgprintf("FreeResource(0x%x) => %d\n", res, result); | |
1954 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1955 } |
1 | 1956 //bool fun(HANDLE) |
1957 //!0 on success | |
3465 | 1958 static int WINAPI expCloseHandle(long v1) |
1 | 1959 { |
128 | 1960 dbgprintf("CloseHandle(0x%x) => 1\n", v1); |
1 | 1961 return 1; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
1962 } |
1 | 1963 |
3465 | 1964 static const char* WINAPI expGetCommandLineA() |
1 | 1965 { |
128 | 1966 dbgprintf("GetCommandLineA() => \"c:\\aviplay.exe\"\n"); |
1 | 1967 return "c:\\aviplay.exe"; |
1968 } | |
128 | 1969 static short envs[]={'p', 'a', 't', 'h', ' ', 'c', ':', '\\', 0, 0}; |
3465 | 1970 static LPWSTR WINAPI expGetEnvironmentStringsW() |
1 | 1971 { |
3465 | 1972 dbgprintf("GetEnvironmentStringsW() => 0\n", envs); |
1973 return 0; | |
1 | 1974 } |
3465 | 1975 static void * WINAPI expRtlZeroMemory(void *p, size_t len) |
121 | 1976 { |
1977 void* result=memset(p,0,len); | |
1978 dbgprintf("RtlZeroMemory(0x%x, len %d) => 0x%x\n",p,len,result); | |
1979 return result; | |
1980 } | |
3465 | 1981 static void * WINAPI expRtlMoveMemory(void *dst, void *src, size_t len) |
121 | 1982 { |
1983 void* result=memmove(dst,src,len); | |
1984 dbgprintf("RtlMoveMemory (dest 0x%x, src 0x%x, len %d) => 0x%x\n",dst,src,len,result); | |
1985 return result; | |
1986 } | |
1987 | |
3465 | 1988 static void * WINAPI expRtlFillMemory(void *p, int ch, size_t len) |
121 | 1989 { |
1990 void* result=memset(p,ch,len); | |
1991 dbgprintf("RtlFillMemory(0x%x, char 0x%x, len %d) => 0x%x\n",p,ch,len,result); | |
1992 return result; | |
1993 } | |
3465 | 1994 static int WINAPI expFreeEnvironmentStringsW(short* strings) |
1 | 1995 { |
128 | 1996 dbgprintf("FreeEnvironmentStringsW(0x%x) => 1\n", strings); |
1 | 1997 return 1; |
1998 } | |
3465 | 1999 static int WINAPI expFreeEnvironmentStringsA(char* strings) |
128 | 2000 { |
3465 | 2001 dbgprintf("FreeEnvironmentStringsA(0x%x) => 1\n", strings); |
2002 return 1; | |
128 | 2003 } |
3465 | 2004 |
128 | 2005 static const char ch_envs[]= |
3465 | 2006 "__MSVCRT_HEAP_SELECT=__GLOBAL_HEAP_SELECTED,1\r\n" |
2007 "PATH=C:\\;C:\\windows\\;C:\\windows\\system\r\n"; | |
2008 static LPCSTR WINAPI expGetEnvironmentStrings() | |
1 | 2009 { |
128 | 2010 dbgprintf("GetEnvironmentStrings() => 0x%x\n", ch_envs); |
2011 return (LPCSTR)ch_envs; | |
3465 | 2012 // dbgprintf("GetEnvironmentStrings() => 0\n"); |
2013 // return 0; | |
1 | 2014 } |
2015 | |
3465 | 2016 static int WINAPI expGetStartupInfoA(STARTUPINFOA *s) |
1 | 2017 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2018 int i; |
128 | 2019 dbgprintf("GetStartupInfoA(0x%x) => 1\n"); |
1 | 2020 memset(s, 0, sizeof(*s)); |
2021 s->cb=sizeof(*s); | |
3465 | 2022 // s->lpReserved="Reserved"; |
2023 // s->lpDesktop="Desktop"; | |
2024 // s->lpTitle="Title"; | |
2025 // s->dwX=s->dwY=0; | |
2026 // s->dwXSize=s->dwYSize=200; | |
2027 s->dwFlags=s->wShowWindow=1; | |
2028 // s->hStdInput=s->hStdOutput=s->hStdError=0x1234; | |
128 | 2029 dbgprintf(" cb=%d\n", s->cb); |
2030 dbgprintf(" lpReserved='%s'\n", s->lpReserved); | |
2031 dbgprintf(" lpDesktop='%s'\n", s->lpDesktop); | |
2032 dbgprintf(" lpTitle='%s'\n", s->lpTitle); | |
2033 dbgprintf(" dwX=%d dwY=%d dwXSize=%d dwYSize=%d\n", | |
3465 | 2034 s->dwX, s->dwY, s->dwXSize, s->dwYSize); |
128 | 2035 dbgprintf(" dwXCountChars=%d dwYCountChars=%d dwFillAttribute=%d\n", |
3465 | 2036 s->dwXCountChars, s->dwYCountChars, s->dwFillAttribute); |
128 | 2037 dbgprintf(" dwFlags=0x%x wShowWindow=0x%x cbReserved2=0x%x\n", |
3465 | 2038 s->dwFlags, s->wShowWindow, s->cbReserved2); |
128 | 2039 dbgprintf(" lpReserved2=0x%x hStdInput=0x%x hStdOutput=0x%x hStdError=0x%x\n", |
3465 | 2040 s->lpReserved2, s->hStdInput, s->hStdOutput, s->hStdError); |
1 | 2041 return 1; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2042 } |
1 | 2043 |
3465 | 2044 static int WINAPI expGetStdHandle(int z) |
1 | 2045 { |
3465 | 2046 dbgprintf("GetStdHandle(0x%x) => 0x%x\n", z+0x1234); |
2047 return z+0x1234; | |
1 | 2048 } |
3465 | 2049 static int WINAPI expGetFileType(int handle) |
1 | 2050 { |
3465 | 2051 dbgprintf("GetFileType(0x%x) => 0x3 = pipe\n", handle); |
2052 return 0x3; | |
1 | 2053 } |
3465 | 2054 static int WINAPI expSetHandleCount(int count) |
1 | 2055 { |
128 | 2056 dbgprintf("SetHandleCount(0x%x) => 1\n", count); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2057 return 1; |
1 | 2058 } |
3465 | 2059 static int WINAPI expGetACP() |
1 | 2060 { |
128 | 2061 dbgprintf("GetACP() => 0\n"); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2062 return 0; |
1 | 2063 } |
2064 extern WINE_MODREF *MODULE32_LookupHMODULE(HMODULE m); | |
3465 | 2065 static int WINAPI expGetModuleFileNameA(int module, char* s, int len) |
1 | 2066 { |
2067 WINE_MODREF *mr; | |
128 | 2068 int result; |
3465 | 2069 // printf("File name of module %X requested\n", module); |
1 | 2070 if(s==0) |
128 | 2071 result=0; |
2072 else | |
3465 | 2073 if(len<35) |
2074 result=0; | |
128 | 2075 else |
3465 | 2076 { |
2077 result=1; | |
2078 strcpy(s, "c:\\windows\\system\\"); | |
2079 mr=MODULE32_LookupHMODULE(module); | |
2080 if(mr==0)//oops | |
2081 strcat(s, "aviplay.dll"); | |
2082 else | |
2083 if(strrchr(mr->filename, '/')==NULL) | |
2084 strcat(s, mr->filename); | |
2085 else | |
2086 strcat(s, strrchr(mr->filename, '/')+1); | |
2087 } | |
128 | 2088 if(!s) |
3465 | 2089 dbgprintf("GetModuleFileNameA(0x%x, 0x%x, %d) => %d\n", |
2090 module, s, len, result); | |
1 | 2091 else |
3465 | 2092 dbgprintf("GetModuleFileNameA(0x%x, 0x%x, %d) => %d ( '%s' )\n", |
2093 module, s, len, result, s); | |
128 | 2094 return result; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2095 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2096 |
3465 | 2097 static int WINAPI expSetUnhandledExceptionFilter(void* filter) |
1 | 2098 { |
128 | 2099 dbgprintf("SetUnhandledExceptionFilter(0x%x) => 1\n", filter); |
1 | 2100 return 1;//unsupported and probably won't ever be supported |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2101 } |
2069 | 2102 |
3465 | 2103 static int WINAPI expLoadLibraryA(char* name) |
1 | 2104 { |
2069 | 2105 int result = 0; |
713 | 2106 char* lastbc; |
2069 | 2107 int i; |
713 | 2108 if (!name) |
2109 return -1; | |
2110 // we skip to the last backslash | |
2111 // this is effectively eliminating weird characters in | |
2112 // the text output windows | |
2069 | 2113 |
713 | 2114 lastbc = strrchr(name, '\\'); |
2115 if (lastbc) | |
2116 { | |
3465 | 2117 int i; |
2118 lastbc++; | |
713 | 2119 for (i = 0; 1 ;i++) |
2120 { | |
2121 name[i] = *lastbc++; | |
2122 if (!name[i]) | |
2123 break; | |
2124 } | |
2125 } | |
2069 | 2126 if(strncmp(name, "c:\\windows\\", 11)==0) name += 11; |
1416 | 2127 if(strncmp(name, ".\\", 2)==0) name += 2; |
2069 | 2128 |
2129 dbgprintf("Entering LoadLibraryA(%s)\n", name); | |
3465 | 2130 |
3440 | 2131 // PIMJ and VIVO audio are loading kernel32.dll |
2132 if (strcasecmp(name, "kernel32.dll") == 0 || strcasecmp(name, "kernel32") == 0) | |
3457 | 2133 // return MODULE_HANDLE_kernel32; |
2134 return ERROR_SUCCESS; /* yeah, we have also the kernel32 calls */ | |
2135 /* exported -> do not return failed! */ | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2136 |
2069 | 2137 result=LoadLibraryA(name); |
2138 dbgprintf("Returned LoadLibraryA(0x%x='%s'), def_path=%s => 0x%x\n", name, name, def_path, result); | |
2139 | |
128 | 2140 return result; |
2069 | 2141 } |
3465 | 2142 static int WINAPI expFreeLibrary(int module) |
1 | 2143 { |
128 | 2144 int result=FreeLibrary(module); |
2145 dbgprintf("FreeLibrary(0x%x) => %d\n", module, result); | |
2146 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2147 } |
3465 | 2148 static void* WINAPI expGetProcAddress(HMODULE mod, char* name) |
1 | 2149 { |
2069 | 2150 void* result; |
2151 if(mod!=MODULE_HANDLE_kernel32) | |
128 | 2152 result=GetProcAddress(mod, name); |
2153 else | |
2154 result=LookupExternalByName("kernel32.dll", name); | |
2155 dbgprintf("GetProcAddress(0x%x, '%s') => 0x%x\n", mod, name, result); | |
2156 return result; | |
2069 | 2157 } |
1 | 2158 |
3465 | 2159 static long WINAPI expCreateFileMappingA(int hFile, void* lpAttr, |
2160 long flProtect, long dwMaxHigh, | |
2161 long dwMaxLow, const char* name) | |
1 | 2162 { |
128 | 2163 long result=CreateFileMappingA(hFile, lpAttr, flProtect, dwMaxHigh, dwMaxLow, name); |
2164 if(!name) | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2165 dbgprintf("CreateFileMappingA(file 0x%x, lpAttr 0x%x," |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2166 "flProtect 0x%x, dwMaxHigh 0x%x, dwMaxLow 0x%x, name 0) => %d\n", |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2167 hFile, lpAttr, flProtect, dwMaxHigh, dwMaxLow, result); |
128 | 2168 else |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2169 dbgprintf("CreateFileMappingA(file 0x%x, lpAttr 0x%x," |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2170 "flProtect 0x%x, dwMaxHigh 0x%x, dwMaxLow 0x%x, name 0x%x='%s') => %d\n", |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2171 hFile, lpAttr, flProtect, dwMaxHigh, dwMaxLow, name, name, result); |
128 | 2172 return result; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2173 } |
1 | 2174 |
3465 | 2175 static long WINAPI expOpenFileMappingA(long hFile, long hz, const char* name) |
1 | 2176 { |
128 | 2177 long result=OpenFileMappingA(hFile, hz, name); |
2178 if(!name) | |
2179 dbgprintf("OpenFileMappingA(0x%x, 0x%x, 0) => %d\n", | |
3465 | 2180 hFile, hz, result); |
128 | 2181 else |
2182 dbgprintf("OpenFileMappingA(0x%x, 0x%x, 0x%x='%s') => %d\n", | |
3465 | 2183 hFile, hz, name, name, result); |
128 | 2184 return result; |
1 | 2185 } |
2186 | |
3465 | 2187 static void* WINAPI expMapViewOfFile(HANDLE file, DWORD mode, DWORD offHigh, |
2188 DWORD offLow, DWORD size) | |
1 | 2189 { |
128 | 2190 dbgprintf("MapViewOfFile(0x%x, 0x%x, 0x%x, 0x%x, size %d) => 0x%x\n", |
3465 | 2191 file,mode,offHigh,offLow,size,(char*)file+offLow); |
1 | 2192 return (char*)file+offLow; |
2193 } | |
2194 | |
3465 | 2195 static void* WINAPI expUnmapViewOfFile(void* view) |
1 | 2196 { |
128 | 2197 dbgprintf("UnmapViewOfFile(0x%x) => 0\n", view); |
1 | 2198 return 0; |
2199 } | |
2200 | |
3465 | 2201 static void* WINAPI expSleep(int time) |
2202 { | |
2203 #if HAVE_NANOSLEEP | |
2204 /* solaris doesn't have thread safe usleep */ | |
2205 struct timespec tsp; | |
2206 tsp.tv_sec = time / 1000000; | |
2207 tsp.tv_nsec = (time % 1000000) * 1000; | |
2208 nanosleep(&tsp, NULL); | |
2209 #else | |
2210 usleep(time); | |
2211 #endif | |
2212 dbgprintf("Sleep(%d) => 0\n", time); | |
2213 return 0; | |
2214 } | |
2215 // why does IV32 codec want to call this? I don't know ... | |
2216 static int WINAPI expCreateCompatibleDC(int hdc) | |
1 | 2217 { |
3465 | 2218 int dc = 0;//0x81; |
2219 //dbgprintf("CreateCompatibleDC(%d) => 0x81\n", hdc); | |
2220 dbgprintf("CreateCompatibleDC(%d) => %d\n", hdc, dc); | |
2221 return dc; | |
2222 } | |
2223 | |
2224 static int WINAPI expGetDeviceCaps(int hdc, int unk) | |
2225 { | |
2226 dbgprintf("GetDeviceCaps(0x%x, %d) => 0\n", hdc, unk); | |
2227 return 0; | |
2228 } | |
2229 | |
2230 static WIN_BOOL WINAPI expDeleteDC(int hdc) | |
2231 { | |
2232 dbgprintf("DeleteDC(0x%x) => 0\n", hdc); | |
2233 if (hdc == 0x81) | |
2234 return 1; | |
1 | 2235 return 0; |
2236 } | |
3465 | 2237 |
2238 static WIN_BOOL WINAPI expDeleteObject(int hdc) | |
1 | 2239 { |
3465 | 2240 dbgprintf("DeleteObject(0x%x) => 1\n", hdc); |
2241 /* FIXME - implement code here */ | |
2242 return 1; | |
1 | 2243 } |
2244 | |
3465 | 2245 /* btvvc32.drv wants this one */ |
2246 static void* WINAPI expGetWindowDC(int hdc) | |
1 | 2247 { |
3465 | 2248 dbgprintf("GetWindowDC(%d) => 0x0\n", hdc); |
3128 | 2249 return 0; |
2250 } | |
2251 | |
3465 | 2252 /* |
2253 * Returns the number of milliseconds, modulo 2^32, since the start | |
2254 * of the wineserver. | |
2255 */ | |
2256 static int WINAPI expGetTickCount(void) | |
1 | 2257 { |
3465 | 2258 static int tcstart = 0; |
2259 struct timeval t; | |
2260 int tc; | |
2261 gettimeofday( &t, NULL ); | |
2262 tc = ((t.tv_sec * 1000) + (t.tv_usec / 1000)) - tcstart; | |
2263 if (tcstart == 0) | |
2264 { | |
2265 tcstart = 0; | |
2266 tc = 0; | |
2267 } | |
2268 dbgprintf("GetTickCount() => %d\n", tc); | |
2269 return tc; | |
1 | 2270 } |
2271 | |
3465 | 2272 static int WINAPI expCreateFontA(void) |
2273 { | |
2274 dbgprintf("CreateFontA() => 0x0\n"); | |
2275 return 1; | |
2276 } | |
2277 | |
2278 /* tried to get pvmjpg work in a different way - no success */ | |
2279 static int WINAPI expDrawTextA(int hDC, char* lpString, int nCount, | |
2280 LPRECT lpRect, unsigned int uFormat) | |
2281 { | |
2282 dbgprintf("expDrawTextA(%p,...) => 8\n", hDC); | |
2283 return 8; | |
2284 } | |
2285 | |
2286 static int WINAPI expGetPrivateProfileIntA(const char* appname, | |
2287 const char* keyname, | |
2288 int default_value, | |
2289 const char* filename) | |
1 | 2290 { |
2291 int size=255; | |
2292 char buffer[256]; | |
2293 char* fullname; | |
2294 int result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2295 |
1 | 2296 buffer[255]=0; |
128 | 2297 if(!(appname && keyname && filename) ) |
2298 { | |
3465 | 2299 dbgprintf("GetPrivateProfileIntA('%s', '%s', %d, '%s') => %d\n", appname, keyname, default_value, filename, default_value ); |
128 | 2300 return default_value; |
2301 } | |
1 | 2302 fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename)); |
2303 strcpy(fullname, "Software\\IniFileMapping\\"); | |
2304 strcat(fullname, appname); | |
2305 strcat(fullname, "\\"); | |
2306 strcat(fullname, keyname); | |
2307 strcat(fullname, "\\"); | |
2308 strcat(fullname, filename); | |
2309 result=RegQueryValueExA(HKEY_LOCAL_MACHINE, fullname, NULL, NULL, (int*)buffer, &size); | |
2310 if((size>=0)&&(size<256)) | |
2311 buffer[size]=0; | |
3465 | 2312 // printf("GetPrivateProfileIntA(%s, %s, %s) -> %s\n", appname, keyname, filename, buffer); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2313 free(fullname); |
1 | 2314 if(result) |
128 | 2315 result=default_value; |
1 | 2316 else |
128 | 2317 result=atoi(buffer); |
2318 dbgprintf("GetPrivateProfileIntA('%s', '%s', %d, '%s') => %d\n", appname, keyname, default_value, filename, result); | |
2319 return result; | |
1 | 2320 } |
3465 | 2321 static int WINAPI expGetProfileIntA(const char* appname, |
2322 const char* keyname, | |
2323 int default_value) | |
128 | 2324 { |
2325 dbgprintf("GetProfileIntA -> "); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2326 return expGetPrivateProfileIntA(appname, keyname, default_value, "default"); |
128 | 2327 } |
2328 | |
3465 | 2329 static int WINAPI expGetPrivateProfileStringA(const char* appname, |
2330 const char* keyname, | |
2331 const char* def_val, | |
2332 char* dest, unsigned int len, | |
2333 const char* filename) | |
1 | 2334 { |
2335 int result; | |
2336 int size; | |
2337 char* fullname; | |
128 | 2338 dbgprintf("GetPrivateProfileStringA('%s', '%s', def_val '%s', 0x%x, 0x%x, '%s')", appname, keyname, def_val, dest, len, filename ); |
1 | 2339 if(!(appname && keyname && filename) ) return 0; |
2340 fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename)); | |
2341 strcpy(fullname, "Software\\IniFileMapping\\"); | |
2342 strcat(fullname, appname); | |
2343 strcat(fullname, "\\"); | |
2344 strcat(fullname, keyname); | |
2345 strcat(fullname, "\\"); | |
2346 strcat(fullname, filename); | |
2347 size=len; | |
2348 result=RegQueryValueExA(HKEY_LOCAL_MACHINE, fullname, NULL, NULL, (int*)dest, &size); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2349 free(fullname); |
128 | 2350 if(result) |
2351 { | |
2352 strncpy(dest, def_val, size); | |
2353 if (strlen(def_val)< size) size = strlen(def_val); | |
2354 } | |
2355 dbgprintf(" => %d ( '%s' )\n", size, dest); | |
1 | 2356 return size; |
2357 } | |
3465 | 2358 static int WINAPI expWritePrivateProfileStringA(const char* appname, |
2359 const char* keyname, | |
2360 const char* string, | |
2361 const char* filename) | |
1 | 2362 { |
2363 int size=256; | |
2364 char* fullname; | |
128 | 2365 dbgprintf("WritePrivateProfileStringA('%s', '%s', '%s', '%s')", appname, keyname, string, filename ); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2366 if(!(appname && keyname && filename) ) |
128 | 2367 { |
2368 dbgprintf(" => -1\n"); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2369 return -1; |
128 | 2370 } |
1 | 2371 fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename)); |
2372 strcpy(fullname, "Software\\IniFileMapping\\"); | |
2373 strcat(fullname, appname); | |
2374 strcat(fullname, "\\"); | |
2375 strcat(fullname, keyname); | |
2376 strcat(fullname, "\\"); | |
2377 strcat(fullname, filename); | |
2378 RegSetValueExA(HKEY_LOCAL_MACHINE, fullname, 0, REG_SZ, (int*)string, strlen(string)); | |
3465 | 2379 // printf("RegSetValueExA(%s,%d)\n", string, strlen(string)); |
2380 // printf("WritePrivateProfileStringA(%s, %s, %s, %s)\n", appname, keyname, string, filename ); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2381 free(fullname); |
128 | 2382 dbgprintf(" => 0\n"); |
1 | 2383 return 0; |
2384 } | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2385 |
1 | 2386 unsigned int _GetPrivateProfileIntA(const char* appname, const char* keyname, INT default_value, const char* filename) |
2387 { | |
2388 return expGetPrivateProfileIntA(appname, keyname, default_value, filename); | |
2389 } | |
2390 int _GetPrivateProfileStringA(const char* appname, const char* keyname, | |
3465 | 2391 const char* def_val, char* dest, unsigned int len, const char* filename) |
1 | 2392 { |
2393 return expGetPrivateProfileStringA(appname, keyname, def_val, dest, len, filename); | |
2394 } | |
2395 int _WritePrivateProfileStringA(const char* appname, const char* keyname, | |
3465 | 2396 const char* string, const char* filename) |
1 | 2397 { |
2398 return expWritePrivateProfileStringA(appname, keyname, string, filename); | |
2399 } | |
2400 | |
2401 | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2402 |
3465 | 2403 static int WINAPI expDefDriverProc(int _private, int id, int msg, int arg1, int arg2) |
1 | 2404 { |
128 | 2405 dbgprintf("DefDriverProc(0x%x, 0x%x, 0x%x, 0x%x, 0x%x) => 0\n", _private, id, msg, arg1, arg2); |
1 | 2406 return 0; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2407 } |
1 | 2408 |
3465 | 2409 static int WINAPI expSizeofResource(int v1, int v2) |
1 | 2410 { |
128 | 2411 int result=SizeofResource(v1, v2); |
2412 dbgprintf("SizeofResource(0x%x, 0x%x) => %d\n", v1, v2, result); | |
2413 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2414 } |
1 | 2415 |
3465 | 2416 static int WINAPI expGetLastError() |
1 | 2417 { |
128 | 2418 int result=GetLastError(); |
2419 dbgprintf("GetLastError() => 0x%x\n", result); | |
2420 return result; | |
1 | 2421 } |
2422 | |
3465 | 2423 static void WINAPI expSetLastError(int error) |
1 | 2424 { |
128 | 2425 dbgprintf("SetLastError(0x%x)\n", error); |
1 | 2426 SetLastError(error); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2427 } |
1 | 2428 |
3465 | 2429 static int WINAPI expStringFromGUID2(GUID* guid, char* str, int cbMax) |
128 | 2430 { |
2069 | 2431 int result=snprintf(str, cbMax, "%.8x-%.4x-%.4x-%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", |
2432 guid->f1, guid->f2, guid->f3, | |
2433 (unsigned char)guid->f4[0], (unsigned char)guid->f4[1], | |
2434 (unsigned char)guid->f4[2], (unsigned char)guid->f4[3], | |
2435 (unsigned char)guid->f4[4], (unsigned char)guid->f4[5], | |
2436 (unsigned char)guid->f4[6], (unsigned char)guid->f4[7]); | |
128 | 2437 dbgprintf("StringFromGUID2(0x%x, 0x%x='%s', %d) => %d\n", guid, str, str, cbMax, result); |
2438 return result; | |
2439 } | |
2440 | |
1 | 2441 |
3465 | 2442 static int WINAPI expGetFileVersionInfoSizeA(const char* name, int* lpHandle) |
1 | 2443 { |
128 | 2444 dbgprintf("GetFileVersionInfoSizeA(0x%x='%s', 0x%X) => 0\n", name, name, lpHandle); |
1 | 2445 return 0; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2446 } |
1 | 2447 |
3465 | 2448 static int WINAPI expIsBadStringPtrW(const short* string, int nchars) |
1 | 2449 { |
128 | 2450 int result; |
2451 if(string==0)result=1; else result=0; | |
2452 dbgprintf("IsBadStringPtrW(0x%x, %d) => %d", string, nchars, result); | |
2453 if(string)wch_print(string); | |
2454 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2455 } |
3465 | 2456 static int WINAPI expIsBadStringPtrA(const char* string, int nchars) |
3128 | 2457 { |
2458 return expIsBadStringPtrW((const short*)string, nchars); | |
2459 } | |
3465 | 2460 static long WINAPI expInterlockedExchangeAdd( long* dest, long incr ) |
1 | 2461 { |
2462 long ret; | |
3465 | 2463 __asm__ __volatile__ |
2464 ( | |
2465 "lock; xaddl %0,(%1)" | |
2466 : "=r" (ret) | |
2467 : "r" (dest), "0" (incr) | |
2468 : "memory" | |
2469 ); | |
1 | 2470 return ret; |
2471 } | |
2472 | |
3465 | 2473 static long WINAPI expInterlockedIncrement( long* dest ) |
1 | 2474 { |
3465 | 2475 long result=expInterlockedExchangeAdd( dest, 1 ) + 1; |
128 | 2476 dbgprintf("InterlockedIncrement(0x%x => %d) => %d\n", dest, *dest, result); |
2477 return result; | |
1 | 2478 } |
3465 | 2479 static long WINAPI expInterlockedDecrement( long* dest ) |
1 | 2480 { |
3465 | 2481 long result=expInterlockedExchangeAdd( dest, -1 ) - 1; |
128 | 2482 dbgprintf("InterlockedDecrement(0x%x => %d) => %d\n", dest, *dest, result); |
2483 return result; | |
1 | 2484 } |
2485 | |
3465 | 2486 static void WINAPI expOutputDebugStringA( const char* string ) |
1 | 2487 { |
128 | 2488 dbgprintf("OutputDebugStringA(0x%x='%s')\n", string); |
1 | 2489 fprintf(stderr, "DEBUG: %s\n", string); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2490 } |
1 | 2491 |
3465 | 2492 static int WINAPI expGetDC(int hwnd) |
1 | 2493 { |
128 | 2494 dbgprintf("GetDC(0x%x) => 0\n", hwnd); |
1 | 2495 return 0; |
2496 } | |
2497 | |
3465 | 2498 static int WINAPI expReleaseDC(int hwnd, int hdc) |
1 | 2499 { |
128 | 2500 dbgprintf("ReleaseDC(0x%x, 0x%x) => 0\n", hwnd, hdc); |
2501 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2502 } |
3465 | 2503 |
2504 static int WINAPI expGetDesktopWindow() | |
128 | 2505 { |
3465 | 2506 dbgprintf("GetDesktopWindow() => 0\n"); |
2507 return 0; | |
128 | 2508 } |
3465 | 2509 |
2510 static int cursor[100]; | |
2511 | |
2512 static int WINAPI expLoadCursorA(int handle,LPCSTR name) | |
2513 { | |
2514 dbgprintf("LoadCursorA(%d, 0x%x='%s') => 0x%x\n", handle, name, (int)&cursor[0]); | |
2515 return (int)&cursor[0]; | |
2516 } | |
2517 static int WINAPI expSetCursor(void *cursor) | |
128 | 2518 { |
2519 dbgprintf("SetCursor(0x%x) => 0x%x\n", cursor, cursor); | |
2520 return (int)cursor; | |
2521 } | |
3465 | 2522 static int WINAPI expGetCursorPos(void *cursor) |
2069 | 2523 { |
2524 dbgprintf("GetCursorPos(0x%x) => 0x%x\n", cursor, cursor); | |
2525 return 1; | |
2526 } | |
3465 | 2527 static int WINAPI expRegisterWindowMessageA(char *message) |
2069 | 2528 { |
2529 dbgprintf("RegisterWindowMessageA(%s)\n", message); | |
2530 return 1; | |
2531 } | |
3465 | 2532 static int WINAPI expGetProcessVersion(int pid) |
2069 | 2533 { |
2534 dbgprintf("GetProcessVersion(%d)\n", pid); | |
2535 return 1; | |
2536 } | |
3465 | 2537 static int WINAPI expGetCurrentThread(void) |
2069 | 2538 { |
3457 | 2539 #warning FIXME! |
2540 dbgprintf("GetCurrentThread() => %x\n", 0xcfcf9898); | |
2779 | 2541 return 0xcfcf9898; |
2069 | 2542 } |
3465 | 2543 static int WINAPI expGetOEMCP(void) |
2069 | 2544 { |
2545 dbgprintf("GetOEMCP()\n"); | |
2546 return 1; | |
2547 } | |
3465 | 2548 static int WINAPI expGetCPInfo(int cp,void *info) |
2069 | 2549 { |
2550 dbgprintf("GetCPInfo()\n"); | |
2551 return 0; | |
2552 } | |
3465 | 2553 static int WINAPI expGetSystemMetrics(int index) |
2069 | 2554 { |
2555 dbgprintf("GetSystemMetrics(%d)\n", index); | |
2556 return 1; | |
2557 } | |
3465 | 2558 static int WINAPI expGetSysColor(int index) |
2069 | 2559 { |
2560 dbgprintf("GetSysColor(%d)\n", index); | |
2561 return 1; | |
2562 } | |
3465 | 2563 static int WINAPI expGetSysColorBrush(int index) |
2069 | 2564 { |
2565 dbgprintf("GetSysColorBrush(%d)\n", index); | |
2566 return 1; | |
2567 } | |
2568 | |
2569 | |
2570 | |
3465 | 2571 static int WINAPI expGetSystemPaletteEntries(int hdc, int iStartIndex, int nEntries, void* lppe) |
128 | 2572 { |
2573 dbgprintf("GetSystemPaletteEntries(0x%x, 0x%x, 0x%x, 0x%x) => 0\n", | |
3465 | 2574 hdc, iStartIndex, nEntries, lppe); |
1 | 2575 return 0; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2576 } |
1 | 2577 |
2578 /* | |
3465 | 2579 typedef struct _TIME_ZONE_INFORMATION { |
2580 long Bias; | |
2581 char StandardName[32]; | |
2582 SYSTEMTIME StandardDate; | |
2583 long StandardBias; | |
2584 char DaylightName[32]; | |
2585 SYSTEMTIME DaylightDate; | |
2586 long DaylightBias; | |
2587 } TIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION; | |
2588 */ | |
2589 | |
2590 static int WINAPI expGetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation) | |
1 | 2591 { |
128 | 2592 const short name[]={'C', 'e', 'n', 't', 'r', 'a', 'l', ' ', 'S', 't', 'a', |
2593 'n', 'd', 'a', 'r', 'd', ' ', 'T', 'i', 'm', 'e', 0}; | |
2594 const short pname[]={'C', 'e', 'n', 't', 'r', 'a', 'l', ' ', 'D', 'a', 'y', | |
2595 'l', 'i', 'g', 'h', 't', ' ', 'T', 'i', 'm', 'e', 0}; | |
2596 dbgprintf("GetTimeZoneInformation(0x%x) => TIME_ZONE_ID_STANDARD\n"); | |
1 | 2597 memset(lpTimeZoneInformation, 0, sizeof(TIME_ZONE_INFORMATION)); |
128 | 2598 lpTimeZoneInformation->Bias=360;//GMT-6 |
2599 memcpy(lpTimeZoneInformation->StandardName, name, sizeof(name)); | |
2600 lpTimeZoneInformation->StandardDate.wMonth=10; | |
2601 lpTimeZoneInformation->StandardDate.wDay=5; | |
2602 lpTimeZoneInformation->StandardDate.wHour=2; | |
2603 lpTimeZoneInformation->StandardBias=0; | |
2604 memcpy(lpTimeZoneInformation->DaylightName, pname, sizeof(pname)); | |
2605 lpTimeZoneInformation->DaylightDate.wMonth=4; | |
2606 lpTimeZoneInformation->DaylightDate.wDay=1; | |
2607 lpTimeZoneInformation->DaylightDate.wHour=2; | |
2608 lpTimeZoneInformation->DaylightBias=-60; | |
2609 return TIME_ZONE_ID_STANDARD; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2610 } |
1 | 2611 |
3465 | 2612 static void WINAPI expGetLocalTime(SYSTEMTIME* systime) |
1 | 2613 { |
2614 time_t local_time; | |
2615 struct tm *local_tm; | |
2616 struct timeval tv; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2617 |
128 | 2618 dbgprintf("GetLocalTime(0x%x)\n"); |
1 | 2619 gettimeofday(&tv, NULL); |
2620 local_time=tv.tv_sec; | |
2621 local_tm=localtime(&local_time); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2622 |
1 | 2623 systime->wYear = local_tm->tm_year + 1900; |
2624 systime->wMonth = local_tm->tm_mon + 1; | |
2625 systime->wDayOfWeek = local_tm->tm_wday; | |
2626 systime->wDay = local_tm->tm_mday; | |
2627 systime->wHour = local_tm->tm_hour; | |
2628 systime->wMinute = local_tm->tm_min; | |
2629 systime->wSecond = local_tm->tm_sec; | |
2630 systime->wMilliseconds = (tv.tv_usec / 1000) % 1000; | |
128 | 2631 dbgprintf(" Year: %d\n Month: %d\n Day of week: %d\n" |
3465 | 2632 " Day: %d\n Hour: %d\n Minute: %d\n Second: %d\n" |
2633 " Milliseconds: %d\n", | |
2634 systime->wYear, systime->wMonth, systime->wDayOfWeek, systime->wDay, | |
2635 systime->wHour, systime->wMinute, systime->wSecond, systime->wMilliseconds); | |
1 | 2636 } |
2637 | |
3465 | 2638 static int WINAPI expGetSystemTime(SYSTEMTIME* systime) |
1 | 2639 { |
2640 time_t local_time; | |
2641 struct tm *local_tm; | |
2642 struct timeval tv; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2643 |
128 | 2644 dbgprintf("GetSystemTime(0x%x)\n", systime); |
1 | 2645 gettimeofday(&tv, NULL); |
2646 local_time=tv.tv_sec; | |
2647 local_tm=gmtime(&local_time); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2648 |
1 | 2649 systime->wYear = local_tm->tm_year + 1900; |
2650 systime->wMonth = local_tm->tm_mon + 1; | |
2651 systime->wDayOfWeek = local_tm->tm_wday; | |
2652 systime->wDay = local_tm->tm_mday; | |
2653 systime->wHour = local_tm->tm_hour; | |
2654 systime->wMinute = local_tm->tm_min; | |
2655 systime->wSecond = local_tm->tm_sec; | |
2656 systime->wMilliseconds = (tv.tv_usec / 1000) % 1000; | |
128 | 2657 dbgprintf(" Year: %d\n Month: %d\n Day of week: %d\n" |
3465 | 2658 " Day: %d\n Hour: %d\n Minute: %d\n Second: %d\n" |
2659 " Milliseconds: %d\n", | |
2660 systime->wYear, systime->wMonth, systime->wDayOfWeek, systime->wDay, | |
2661 systime->wHour, systime->wMinute, systime->wSecond, systime->wMilliseconds); | |
2069 | 2662 return 0; |
1 | 2663 } |
2664 | |
3465 | 2665 static int WINAPI expGetEnvironmentVariableA(const char* name, char* field, int size) |
1 | 2666 { |
128 | 2667 char *p; |
3465 | 2668 // printf("%s %x %x\n", name, field, size); |
1 | 2669 if(field)field[0]=0; |
3465 | 2670 /* |
2671 p = getenv(name); | |
2672 if (p) strncpy(field,p,size); | |
2673 */ | |
128 | 2674 if (strcmp(name,"__MSVCRT_HEAP_SELECT")==0) |
3465 | 2675 strcpy(field,"__GLOBAL_HEAP_SELECTED,1"); |
128 | 2676 dbgprintf("GetEnvironmentVariableA(0x%x='%s', 0x%x, %d) => %d\n", name, name, field, size, strlen(field)); |
2677 return strlen(field); | |
2678 } | |
2679 | |
3465 | 2680 static void* WINAPI expCoTaskMemAlloc(ULONG cb) |
128 | 2681 { |
2682 return my_mreq(cb, 0); | |
2683 } | |
3465 | 2684 static void WINAPI expCoTaskMemFree(void* cb) |
128 | 2685 { |
2686 my_release(cb); | |
2687 } | |
2688 | |
3465 | 2689 |
2690 | |
2691 | |
3547 | 2692 void* CoTaskMemAlloc(unsigned long cb) |
3465 | 2693 { |
2694 return expCoTaskMemAlloc(cb); | |
2695 } | |
2696 void CoTaskMemFree(void* cb) | |
2697 { | |
2698 expCoTaskMemFree(cb); | |
2699 } | |
128 | 2700 |
2701 struct COM_OBJECT_INFO | |
2702 { | |
2703 GUID clsid; | |
2704 long (*GetClassObject) (GUID* clsid, GUID* iid, void** ppv); | |
2705 }; | |
2706 | |
2707 static struct COM_OBJECT_INFO* com_object_table=0; | |
2708 static int com_object_size=0; | |
2709 int RegisterComClass(GUID* clsid, GETCLASSOBJECT gcs) | |
2710 { | |
2069 | 2711 if(!clsid || !gcs) |
2712 return -1; | |
128 | 2713 com_object_table=realloc(com_object_table, sizeof(struct COM_OBJECT_INFO)*(++com_object_size)); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2714 com_object_table[com_object_size-1].clsid=*clsid; |
128 | 2715 com_object_table[com_object_size-1].GetClassObject=gcs; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2716 return 0; |
128 | 2717 } |
2718 | |
2069 | 2719 int UnregisterComClass(GUID* clsid, GETCLASSOBJECT gcs) |
2720 { | |
2721 int found = 0; | |
2722 int i = 0; | |
2723 if(!clsid || !gcs) | |
2724 return -1; | |
2725 | |
2726 if (com_object_table == 0) | |
2727 printf("Warning: UnregisterComClass() called without any registered class\n"); | |
2728 while (i < com_object_size) | |
2729 { | |
2730 if (found && i > 0) | |
2731 { | |
2732 memcpy(&com_object_table[i - 1].clsid, | |
2733 &com_object_table[i].clsid, sizeof(GUID)); | |
2734 com_object_table[i - 1].GetClassObject = | |
2735 com_object_table[i].GetClassObject; | |
2736 } | |
2737 else if (memcmp(&com_object_table[i].clsid, clsid, sizeof(GUID)) == 0 | |
2738 && com_object_table[i].GetClassObject == gcs) | |
2739 { | |
3465 | 2740 found++; |
2069 | 2741 } |
2742 i++; | |
2743 } | |
2744 if (found) | |
2745 { | |
2746 if (--com_object_size == 0) | |
2747 { | |
2748 free(com_object_table); | |
3465 | 2749 com_object_table = 0; |
2069 | 2750 } |
2751 } | |
2752 return 0; | |
2753 } | |
2754 | |
2755 | |
3465 | 2756 GUID IID_IUnknown = |
2757 { | |
2758 0x00000000, 0x0000, 0x0000, | |
2759 {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} | |
2760 }; | |
2761 GUID IID_IClassFactory = | |
2762 { | |
2763 0x00000001, 0x0000, 0x0000, | |
2764 {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} | |
2765 }; | |
2766 | |
2767 static long WINAPI expCoCreateInstance(GUID* rclsid, struct IUnknown* pUnkOuter, | |
2768 long dwClsContext, GUID* riid, void** ppv) | |
128 | 2769 { |
2770 int i; | |
2771 struct COM_OBJECT_INFO* ci=0; | |
2772 for(i=0; i<com_object_size; i++) | |
2773 if(!memcmp(rclsid, &com_object_table[i].clsid, sizeof(GUID))) | |
2774 ci=&com_object_table[i]; | |
3465 | 2775 if(!ci)return REGDB_E_CLASSNOTREG; |
128 | 2776 // in 'real' world we should mess with IClassFactory here |
2777 i=ci->GetClassObject(rclsid, riid, ppv); | |
2778 return i; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2779 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2780 |
128 | 2781 long CoCreateInstance(GUID* rclsid, struct IUnknown* pUnkOuter, |
3465 | 2782 long dwClsContext, GUID* riid, void** ppv) |
128 | 2783 { |
2784 return expCoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv); | |
2785 } | |
2786 | |
3465 | 2787 static int WINAPI expIsRectEmpty(CONST RECT *lprc) |
128 | 2788 { |
3465 | 2789 int r = (!lprc || (lprc->right == lprc->left) || (lprc->top == lprc->bottom)); |
2790 dbgprintf("IsRectEmpty(%p) => %s\n", lprc, (r) ? "TRUE" : "FALSE"); | |
2791 return r; | |
128 | 2792 } |
2793 | |
3465 | 2794 static int _adjust_fdiv=0; //what's this? - used to adjust division |
2795 | |
2796 | |
2797 | |
2798 | |
2799 static unsigned int WINAPI expGetTempPathA(unsigned int len, char* path) | |
128 | 2800 { |
2801 dbgprintf("GetTempPathA(%d, 0x%x)", len, path); | |
2802 if(len<5) | |
2803 { | |
2804 dbgprintf(" => 0\n"); | |
2805 return 0; | |
2806 } | |
2807 strcpy(path, "/tmp"); | |
2808 dbgprintf(" => 5 ( '/tmp' )\n"); | |
2809 return 5; | |
2810 } | |
2811 /* | |
3465 | 2812 FYI: |
2813 typedef struct | |
2814 { | |
2815 DWORD dwFileAttributes; | |
2816 FILETIME ftCreationTime; | |
2817 FILETIME ftLastAccessTime; | |
2818 FILETIME ftLastWriteTime; | |
2819 DWORD nFileSizeHigh; | |
2820 DWORD nFileSizeLow; | |
2821 DWORD dwReserved0; | |
2822 DWORD dwReserved1; | |
2823 CHAR cFileName[260]; | |
2824 CHAR cAlternateFileName[14]; | |
2825 } WIN32_FIND_DATAA, *LPWIN32_FIND_DATAA; | |
2826 */ | |
2827 | |
2828 static HANDLE WINAPI expFindFirstFileA(LPCSTR s, LPWIN32_FIND_DATAA lpfd) | |
128 | 2829 { |
2830 dbgprintf("FindFirstFileA(0x%x='%s', 0x%x) => 0\n", s, s, lpfd); | |
2831 strcpy(lpfd->cFileName, "msms001.vwp"); | |
2832 strcpy(lpfd->cAlternateFileName, "msms001.vwp"); | |
2833 return (HANDLE)0; | |
2834 } | |
3465 | 2835 static WIN_BOOL WINAPI expFindNextFileA(HANDLE h,LPWIN32_FIND_DATAA p) |
128 | 2836 { |
2837 dbgprintf("FindNextFileA(0x%x, 0x%x) => 0\n", h, p); | |
1 | 2838 return 0; |
2839 } | |
3465 | 2840 static WIN_BOOL WINAPI expFindClose(HANDLE h) |
128 | 2841 { |
2842 dbgprintf("FindClose(0x%x) => 0\n", h); | |
2843 return 0; | |
2844 } | |
3465 | 2845 static UINT WINAPI expSetErrorMode(UINT i) |
128 | 2846 { |
2847 dbgprintf("SetErrorMode(%d) => 0\n", i); | |
2848 return 0; | |
2849 } | |
3465 | 2850 static UINT WINAPI expGetWindowsDirectoryA(LPSTR s,UINT c) |
128 | 2851 { |
2852 char windir[]="c:\\windows"; | |
2853 int result; | |
2854 strncpy(s, windir, c); | |
2855 result=1+((c<strlen(windir))?c:strlen(windir)); | |
2856 dbgprintf("GetWindowsDirectoryA(0x%x, %d) => %d\n", s, c, result); | |
2857 return result; | |
2858 } | |
2859 | |
3465 | 2860 static WIN_BOOL WINAPI expDeleteFileA(LPCSTR s) |
128 | 2861 { |
2862 dbgprintf("DeleteFileA(0x%x='%s') => 0\n", s, s); | |
2863 return 0; | |
2864 } | |
3465 | 2865 static WIN_BOOL WINAPI expFileTimeToLocalFileTime(const FILETIME* cpf, LPFILETIME pf) |
128 | 2866 { |
2867 dbgprintf("FileTimeToLocalFileTime(0x%x, 0x%x) => 0\n", cpf, pf); | |
2868 return 0; | |
2869 } | |
2870 | |
3465 | 2871 static UINT WINAPI expGetTempFileNameA(LPCSTR cs1,LPCSTR cs2,UINT i,LPSTR ps) |
128 | 2872 { |
2873 char mask[16]="/tmp/AP_XXXXXX"; | |
2874 int result; | |
2875 dbgprintf("GetTempFileNameA(0x%x='%s', 0x%x='%s', %d, 0x%x)", cs1, cs1, cs2, cs2, i, ps); | |
2876 if(i && i<10) | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2877 { |
128 | 2878 dbgprintf(" => -1\n"); |
2879 return -1; | |
2880 } | |
2881 result=mkstemp(mask); | |
2882 sprintf(ps, "AP%d", result); | |
2883 dbgprintf(" => %d\n", strlen(ps)); | |
2884 return strlen(ps); | |
2885 } | |
2886 // | |
2887 // This func might need proper implementation if we want AngelPotion codec. | |
2888 // They try to open APmpeg4v1.apl with it. | |
2889 // DLL will close opened file with CloseHandle(). | |
2890 // | |
3465 | 2891 static HANDLE WINAPI expCreateFileA(LPCSTR cs1,DWORD i1,DWORD i2, |
2892 LPSECURITY_ATTRIBUTES p1, DWORD i3,DWORD i4,HANDLE i5) | |
128 | 2893 { |
2894 dbgprintf("CreateFileA(0x%x='%s', %d, %d, 0x%x, %d, %d, 0x%x)\n", cs1, cs1, i1, | |
3465 | 2895 i2, p1, i3, i4, i5); |
128 | 2896 if((!cs1) || (strlen(cs1)<2))return -1; |
3128 | 2897 |
2898 if(strncmp(cs1, "AP", 2) == 0) | |
128 | 2899 { |
2900 int result; | |
2901 char* tmp=(char*)malloc(strlen(def_path)+50); | |
2902 strcpy(tmp, def_path); | |
2903 strcat(tmp, "/"); | |
2904 strcat(tmp, "APmpg4v1.apl"); | |
2905 result=open(tmp, O_RDONLY); | |
2906 free(tmp); | |
2907 return result; | |
3128 | 2908 } |
2909 if (strstr(cs1, "vp3")) | |
2910 { | |
2911 int r; | |
2912 int flg = 0; | |
2913 char* tmp=(char*)malloc(20 + strlen(cs1)); | |
2914 strcpy(tmp, "/tmp/"); | |
2915 strcat(tmp, cs1); | |
2916 r = 4; | |
2917 while (tmp[r]) | |
2918 { | |
2919 if (tmp[r] == ':' || tmp[r] == '\\') | |
2920 tmp[r] = '_'; | |
2921 r++; | |
2922 } | |
2923 if (GENERIC_READ & i1) | |
2924 flg |= O_RDONLY; | |
2925 else if (GENERIC_WRITE & i1) | |
2926 { | |
2927 flg |= O_WRONLY; | |
2928 printf("Warning: openning filename %s %d (flags; 0x%x) for write\n", tmp, r, flg); | |
2929 } | |
2930 r=open(tmp, flg); | |
2931 free(tmp); | |
2932 return r; | |
2933 } | |
2934 | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2935 return atoi(cs1+2); |
128 | 2936 } |
2937 static char sysdir[]="."; | |
3465 | 2938 static LPCSTR WINAPI expGetSystemDirectoryA() |
128 | 2939 { |
2940 dbgprintf("GetSystemDirectoryA() => 0x%x='%s'\n", sysdir, sysdir); | |
2941 return sysdir; | |
2942 } | |
3465 | 2943 static WIN_BOOL WINAPI expReadFile(HANDLE h,LPVOID pv,DWORD size,LPDWORD rd,LPOVERLAPPED unused) |
128 | 2944 { |
2945 int result; | |
2946 dbgprintf("ReadFile(%d, 0x%x, %d -> 0x%x)\n", h, pv, size, rd); | |
2947 result=read(h, pv, size); | |
2948 if(rd)*rd=result; | |
2949 if(!result)return 0; | |
2950 return 1; | |
2951 } | |
2952 | |
3465 | 2953 static WIN_BOOL WINAPI expWriteFile(HANDLE h,LPCVOID pv,DWORD size,LPDWORD wr,LPOVERLAPPED unused) |
128 | 2954 { |
2955 int result; | |
2956 dbgprintf("WriteFile(%d, 0x%x, %d -> 0x%x)\n", h, pv, size, wr); | |
2957 if(h==1234)h=1; | |
2958 result=write(h, pv, size); | |
2959 if(wr)*wr=result; | |
2960 if(!result)return 0; | |
2961 return 1; | |
2962 } | |
3465 | 2963 static DWORD WINAPI expSetFilePointer(HANDLE h, LONG val, LPLONG ext, DWORD whence) |
128 | 2964 { |
2965 int wh; | |
2966 dbgprintf("SetFilePointer(%d, %d, 0x%x, %d)\n", h, val, ext, whence); | |
3465 | 2967 //why would DLL want temporary file with >2Gb size? |
128 | 2968 switch(whence) |
2969 { | |
2970 case FILE_BEGIN: | |
2971 wh=SEEK_SET;break; | |
2972 case FILE_END: | |
2973 wh=SEEK_END;break; | |
2974 case FILE_CURRENT: | |
2975 wh=SEEK_CUR;break; | |
2976 default: | |
2977 return -1; | |
2978 } | |
2979 return lseek(h, val, wh); | |
2980 } | |
2981 | |
3465 | 2982 static HDRVR WINAPI expOpenDriverA(LPCSTR szDriverName, LPCSTR szSectionName, |
2983 LPARAM lParam2) | |
128 | 2984 { |
2985 dbgprintf("OpenDriverA(0x%x='%s', 0x%x='%s', 0x%x) => -1\n", szDriverName, szDriverName, szSectionName, szSectionName, lParam2); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2986 return -1; |
128 | 2987 } |
3465 | 2988 static HDRVR WINAPI expOpenDriver(LPCSTR szDriverName, LPCSTR szSectionName, |
2989 LPARAM lParam2) | |
128 | 2990 { |
2991 dbgprintf("OpenDriver(0x%x='%s', 0x%x='%s', 0x%x) => -1\n", szDriverName, szDriverName, szSectionName, szSectionName, lParam2); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
2992 return -1; |
128 | 2993 } |
1 | 2994 |
2995 | |
3465 | 2996 static WIN_BOOL WINAPI expGetProcessAffinityMask(HANDLE hProcess, |
2997 LPDWORD lpProcessAffinityMask, | |
2998 LPDWORD lpSystemAffinityMask) | |
128 | 2999 { |
3000 dbgprintf("GetProcessAffinityMask(0x%x, 0x%x, 0x%x) => 1\n", | |
3465 | 3001 hProcess, lpProcessAffinityMask, lpSystemAffinityMask); |
128 | 3002 if(lpProcessAffinityMask)*lpProcessAffinityMask=1; |
3003 if(lpSystemAffinityMask)*lpSystemAffinityMask=1; | |
3004 return 1; | |
1 | 3005 } |
3006 | |
3465 | 3007 static int WINAPI expMulDiv(int nNumber, int nNumerator, int nDenominator) |
713 | 3008 { |
3009 static const long long max_int=0x7FFFFFFFLL; | |
3010 static const long long min_int=-0x80000000LL; | |
3011 long long tmp=(long long)nNumber*(long long)nNumerator; | |
3465 | 3012 dbgprintf("expMulDiv %d * %d / %d\n", nNumber, nNumerator, nDenominator); |
713 | 3013 if(!nDenominator)return 1; |
3014 tmp/=nDenominator; | |
3015 if(tmp<min_int) return 1; | |
3016 if(tmp>max_int) return 1; | |
3017 return (int)tmp; | |
3018 } | |
3019 | |
3465 | 3020 static LONG WINAPI explstrcmpiA(const char* str1, const char* str2) |
713 | 3021 { |
3022 LONG result=strcasecmp(str1, str2); | |
3023 dbgprintf("strcmpi(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result); | |
3024 return result; | |
3025 } | |
3026 | |
3465 | 3027 static LONG WINAPI explstrlenA(const char* str1) |
713 | 3028 { |
3029 LONG result=strlen(str1); | |
3134 | 3030 dbgprintf("strlen(0x%x='%.50s') => %d\n", str1, str1, result); |
713 | 3031 return result; |
3032 } | |
3033 | |
3465 | 3034 static LONG WINAPI explstrcpyA(char* str1, const char* str2) |
713 | 3035 { |
3036 int result= (int) strcpy(str1, str2); | |
3134 | 3037 dbgprintf("strcpy(0x%.50x, 0x%.50x='%.50s') => %d\n", str1, str2, str2, result); |
713 | 3038 return result; |
3039 } | |
3465 | 3040 static LONG WINAPI explstrcpynA(char* str1, const char* str2,int len) |
2069 | 3041 { |
3042 int result; | |
3043 if (strlen(str2)>len) | |
3465 | 3044 result = (int) strncpy(str1, str2,len); |
2069 | 3045 else |
3465 | 3046 result = (int) strcpy(str1,str2); |
2069 | 3047 dbgprintf("strncpy(0x%x, 0x%x='%s' len %d strlen %d) => %x\n", str1, str2, str2,len, strlen(str2),result); |
3048 return result; | |
3049 } | |
3465 | 3050 static LONG WINAPI explstrcatA(char* str1, const char* str2) |
2069 | 3051 { |
3052 int result= (int) strcat(str1, str2); | |
3053 dbgprintf("strcat(0x%x, 0x%x='%s') => %d\n", str1, str2, str2, result); | |
3054 return result; | |
3055 } | |
3056 | |
128 | 3057 |
3465 | 3058 static LONG WINAPI expInterlockedExchange(long *dest, long l) |
497 | 3059 { |
3465 | 3060 long retval = *dest; |
3061 *dest = l; | |
3062 return retval; | |
497 | 3063 } |
3064 | |
3465 | 3065 static void WINAPI expInitCommonControls(void) |
1543 | 3066 { |
2069 | 3067 printf("InitCommonControls called!\n"); |
3068 return; | |
1543 | 3069 } |
3070 | |
3457 | 3071 /* alex: implement this call! needed for 3ivx */ |
3465 | 3072 static HRESULT WINAPI expCoCreateFreeThreadedMarshaler(void *pUnkOuter, void **ppUnkInner) |
2396 | 3073 { |
3074 printf("CoCreateFreeThreadedMarshaler(%p, %p) called!\n", | |
3465 | 3075 pUnkOuter, ppUnkInner); |
3457 | 3076 return ERROR_CALL_NOT_IMPLEMENTED; |
2396 | 3077 } |
3078 | |
2779 | 3079 |
3465 | 3080 static int WINAPI expDuplicateHandle(HANDLE hSourceProcessHandle, // handle to source process |
3081 HANDLE hSourceHandle, // handle to duplicate | |
3082 HANDLE hTargetProcessHandle, // handle to target process | |
3083 HANDLE* lpTargetHandle, // duplicate handle | |
3084 DWORD dwDesiredAccess, // requested access | |
3085 int bInheritHandle, // handle inheritance option | |
3086 DWORD dwOptions // optional actions | |
3087 ) | |
2779 | 3088 { |
3089 dbgprintf("DuplicateHandle(%p, %p, %p, %p, 0x%x, %d, %d) called\n", | |
3465 | 3090 hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, |
3091 lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions); | |
2779 | 3092 *lpTargetHandle = hSourceHandle; |
3093 return 1; | |
3094 } | |
3095 | |
3128 | 3096 // required by PIM1 codec (used by win98 PCTV Studio capture sw) |
3465 | 3097 static HRESULT WINAPI expCoInitialize( |
3098 LPVOID lpReserved /* [in] pointer to win32 malloc interface | |
3099 (obsolete, should be NULL) */ | |
3100 ) | |
3033 | 3101 { |
3465 | 3102 /* |
3103 * Just delegate to the newer method. | |
3104 */ | |
3105 return 0; //CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED); | |
3033 | 3106 } |
3107 | |
3465 | 3108 static DWORD WINAPI expSetThreadAffinityMask |
3441 | 3109 ( |
3110 HANDLE hThread, | |
3111 DWORD dwThreadAffinityMask | |
3112 ){ | |
3113 return 0; | |
3114 }; | |
3033 | 3115 |
3465 | 3116 /* |
3117 * no WINAPI functions - CDECL | |
3118 */ | |
3119 static void* expmalloc(int size) | |
3120 { | |
3121 //printf("malloc"); | |
3122 // return malloc(size); | |
3123 void* result=my_mreq(size,0); | |
3124 dbgprintf("malloc(0x%x) => 0x%x\n", size,result); | |
3125 if(result==0) | |
3126 printf("WARNING: malloc() failed\n"); | |
3127 return result; | |
3128 } | |
3129 static void expfree(void* mem) | |
3130 { | |
3131 // return free(mem); | |
3132 dbgprintf("free(%p)\n", mem); | |
3133 my_release(mem); | |
3134 } | |
3135 static void* expnew(int size) | |
3136 { | |
3137 // printf("NEW:: Call from address %08x\n STACK DUMP:\n", *(-1+(int*)&size)); | |
3138 // printf("%08x %08x %08x %08x\n", | |
3139 // size, *(1+(int*)&size), | |
3140 // *(2+(int*)&size),*(3+(int*)&size)); | |
3141 void* result; | |
3142 assert(size >= 0); | |
3143 | |
3144 result=my_mreq(size,0); | |
3145 dbgprintf("new(%d) => %p\n", size, result); | |
3146 if (result==0) | |
3147 printf("WARNING: new() failed\n"); | |
3148 return result; | |
3149 | |
3150 } | |
3151 static int expdelete(void* memory) | |
3152 { | |
3153 dbgprintf("delete(%p)\n", memory); | |
3154 my_release(memory); | |
3155 return 0; | |
3156 } | |
3157 static int exp_initterm(int v1, int v2) | |
3158 { | |
3159 dbgprintf("_initterm(0x%x, 0x%x) => 0\n", v1, v2); | |
3160 return 0; | |
3161 } | |
3162 | |
3163 static int expwsprintfA(char* string, char* format, ...) | |
3164 { | |
3165 va_list va; | |
3166 int result; | |
3167 va_start(va, format); | |
3168 result = vsprintf(string, format, va); | |
3169 dbgprintf("wsprintfA(0x%x, '%s', ...) => %d\n", string, format, result); | |
3170 va_end(va); | |
3171 return result; | |
3172 } | |
3173 | |
3174 static int expsprintf(char* str, const char* format, ...) | |
3175 { | |
3176 va_list args; | |
3177 int r; | |
3178 dbgprintf("sprintf(%s, %s)\n", str, format); | |
3179 va_start(args, format); | |
3180 r = vsprintf(str, format, args); | |
3181 va_end(args); | |
3182 return r; | |
3183 } | |
3184 static int expsscanf(const char* str, const char* format, ...) | |
3185 { | |
3186 va_list args; | |
3187 int r; | |
3188 dbgprintf("sscanf(%s, %s)\n", str, format); | |
3189 va_start(args, format); | |
3190 r = vsscanf(str, format, args); | |
3191 va_end(args); | |
3192 return r; | |
3193 } | |
3194 static void* expfopen(const char* path, const char* mode) | |
3195 { | |
3196 printf("fopen: \"%s\" mode:%s\n", path, mode); | |
3197 //return fopen(path, mode); | |
3198 return fdopen(0, mode); // everything on screen | |
3199 } | |
3200 static int expfprintf(void* stream, const char* format, ...) | |
3201 { | |
3202 va_list args; | |
3203 int r = 0; | |
3204 dbgprintf("fprintf(%p, %s, ...)\n", stream, format); | |
3205 #if 1 | |
3206 va_start(args, format); | |
3207 r = vfprintf((FILE*) stream, format, args); | |
3208 va_end(args); | |
3209 #endif | |
3210 return r; | |
3211 } | |
3212 | |
3213 static int expprintf(const char* format, ...) | |
3214 { | |
3215 va_list args; | |
3216 int r; | |
3217 dbgprintf("printf(%s, ...)\n", format); | |
3218 va_start(args, format); | |
3219 r = vprintf(format, args); | |
3220 va_end(args); | |
3221 return r; | |
3222 } | |
3223 | |
3224 static char* expgetenv(const char* varname) | |
3225 { | |
3226 char* v = getenv(varname); | |
3227 dbgprintf("getenv(%s) => %s\n", varname, v); | |
3228 return v; | |
3229 } | |
3230 | |
3231 static void* expwcscpy(WCHAR* dst, const WCHAR* src) | |
3232 { | |
3233 WCHAR* p = dst; | |
3234 while ((*p++ = *src++)) | |
3235 ; | |
3236 return dst; | |
3237 } | |
3238 | |
3239 static char* expstrrchr(char* string, int value) | |
3240 { | |
3241 char* result=strrchr(string, value); | |
3242 if(result) | |
3243 dbgprintf("strrchr(0x%x='%s', %d) => 0x%x='%s'", string, string, value, result, result); | |
3244 else | |
3245 dbgprintf("strrchr(0x%x='%s', %d) => 0", string, string, value); | |
3246 return result; | |
3247 } | |
3248 | |
3249 static char* expstrchr(char* string, int value) | |
3250 { | |
3251 char* result=strchr(string, value); | |
3252 if(result) | |
3253 dbgprintf("strchr(0x%x='%s', %d) => 0x%x='%s'", string, string, value, result, result); | |
3254 else | |
3255 dbgprintf("strchr(0x%x='%s', %d) => 0", string, string, value); | |
3256 return result; | |
3257 } | |
3258 static int expstrlen(char* str) | |
3259 { | |
3260 int result=strlen(str); | |
3261 dbgprintf("strlen(0x%x='%s') => %d\n", str, str, result); | |
3262 return result; | |
3263 } | |
3264 static char* expstrcpy(char* str1, const char* str2) | |
3265 { | |
3266 char* result= strcpy(str1, str2); | |
3267 dbgprintf("strcpy(0x%x, 0x%x='%s') => %p\n", str1, str2, str2, result); | |
3268 return result; | |
3269 } | |
3270 static int expstrcmp(const char* str1, const char* str2) | |
3271 { | |
3272 int result=strcmp(str1, str2); | |
3273 dbgprintf("strcmp(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result); | |
3274 return result; | |
3275 } | |
3276 static int expstrncmp(const char* str1, const char* str2,int x) | |
3277 { | |
3278 int result=strncmp(str1, str2,x); | |
3279 dbgprintf("strcmp(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result); | |
3280 return result; | |
3281 } | |
3282 static char* expstrcat(char* str1, const char* str2) | |
3283 { | |
3284 char* result = strcat(str1, str2); | |
3285 dbgprintf("strcat(0x%x='%s', 0x%x='%s') => %p\n", str1, str1, str2, str2, result); | |
3286 return result; | |
3287 } | |
3288 static char* exp_strdup(const char* str1) | |
3289 { | |
3290 int l = strlen(str1); | |
3291 char* result = my_mreq(l + 1,0); | |
3292 if (result) | |
3293 strcpy(result, str1); | |
3294 dbgprintf("_strdup(0x%x='%s') => %p\n", str1, str1, result); | |
3295 return result; | |
3296 } | |
3297 static int expisalnum(int c) | |
3298 { | |
3299 int result= (int) isalnum(c); | |
3300 dbgprintf("isalnum(0x%x='%c' => %d\n", c, c, result); | |
3301 return result; | |
3302 } | |
3672
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3303 static int expisspace(int c) |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3304 { |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3305 int result= (int) isspace(c); |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3306 dbgprintf("isspace(0x%x='%c' => %d\n", c, c, result); |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3307 return result; |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3308 } |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3309 static int expisalpha(int c) |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3310 { |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3311 int result= (int) isalpha(c); |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3312 dbgprintf("isalpha(0x%x='%c' => %d\n", c, c, result); |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3313 return result; |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3314 } |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3315 static int expisdigit(int c) |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3316 { |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3317 int result= (int) isdigit(c); |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3318 dbgprintf("isdigit(0x%x='%c' => %d\n", c, c, result); |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3319 return result; |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3320 } |
3465 | 3321 static void* expmemmove(void* dest, void* src, int n) |
3322 { | |
3323 void* result = memmove(dest, src, n); | |
3324 dbgprintf("memmove(0x%x, 0x%x, %d) => %p\n", dest, src, n, result); | |
3325 return result; | |
3326 } | |
3327 static int expmemcmp(void* dest, void* src, int n) | |
3328 { | |
3329 int result = memcmp(dest, src, n); | |
3330 dbgprintf("memcmp(0x%x, 0x%x, %d) => %d\n", dest, src, n, result); | |
3331 return result; | |
3332 } | |
3333 static void* expmemcpy(void* dest, void* src, int n) | |
3334 { | |
3335 void *result = memcpy(dest, src, n); | |
3336 dbgprintf("memcpy(0x%x, 0x%x, %d) => %p\n", dest, src, n, result); | |
3337 return result; | |
3338 } | |
3672
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3339 static void* expmemset(void* dest, int c, size_t n) |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3340 { |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3341 void *result = memset(dest, c, n); |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3342 dbgprintf("memset(0x%x, %d, %d) => %p\n", dest, c, n, result); |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3343 return result; |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3344 } |
3465 | 3345 static time_t exptime(time_t* t) |
3346 { | |
3347 time_t result = time(t); | |
3348 dbgprintf("time(0x%x) => %d\n", t, result); | |
3349 return result; | |
3350 } | |
3351 | |
3352 static int exprand(void) | |
3353 { | |
3354 return rand(); | |
3355 } | |
3356 | |
3357 static void expsrand(int seed) | |
3358 { | |
3359 srand(seed); | |
3360 } | |
3361 | |
3362 #if 1 | |
3363 | |
3364 // prefered compilation with -O2 -ffast-math ! | |
3365 | |
3366 static double explog10(double x) | |
3367 { | |
3368 /*printf("Log10 %f => %f 0x%Lx\n", x, log10(x), *((int64_t*)&x));*/ | |
3369 return log10(x); | |
3370 } | |
3371 | |
3372 static double expcos(double x) | |
3373 { | |
3374 /*printf("Cos %f => %f 0x%Lx\n", x, cos(x), *((int64_t*)&x));*/ | |
3375 return cos(x); | |
3376 } | |
3377 | |
3378 /* doens't work */ | |
3379 static long exp_ftol_wrong(double x) | |
3380 { | |
3381 return (long) x; | |
3382 } | |
3383 | |
3384 #else | |
3385 | |
3386 static void explog10(void) | |
3387 { | |
3388 __asm__ __volatile__ | |
3389 ( | |
3390 "fldl 8(%esp) \n\t" | |
3391 "fldln2 \n\t" | |
3392 "fxch %st(1) \n\t" | |
3393 "fyl2x \n\t" | |
3394 ); | |
3395 } | |
3396 | |
3397 static void expcos(void) | |
3398 { | |
3399 __asm__ __volatile__ | |
3400 ( | |
3401 "fldl 8(%esp) \n\t" | |
3402 "fcos \n\t" | |
3403 ); | |
3404 } | |
3405 | |
3406 #endif | |
3407 | |
3408 // this seem to be the only how to make this function working properly | |
3409 // ok - I've spent tremendous amount of time (many many many hours | |
3410 // of debuging fixing & testing - it's almost unimaginable - kabi | |
3411 | |
3412 // _ftol - operated on the float value which is already on the FPU stack | |
3413 static void exp_ftol(void) | |
3414 { | |
3415 __asm__ __volatile__ | |
3416 ( | |
3417 "sub $12, %esp \n\t" | |
3418 "fstcw -2(%ebp) \n\t" | |
3419 "wait \n\t" | |
3420 "mov -2(%ebp), %ax \n\t" | |
3421 "or $0x0C, %ah \n\t" | |
3422 "mov %ax, -4(%ebp) \n\t" | |
3423 "fldcw -4(%ebp) \n\t" | |
3424 "fistpl -12(%ebp) \n\t" | |
3425 "fldcw -2(%ebp) \n\t" | |
3426 "mov -12(%ebp), %eax \n\t" | |
3427 ); | |
3428 } | |
3429 | |
3430 static double exppow(double x, double y) | |
3431 { | |
3432 /*printf("Pow %f %f 0x%Lx 0x%Lx => %f\n", x, y, *((int64_t*)&x), *((int64_t*)&y), pow(x, y));*/ | |
3433 return pow(x, y); | |
3434 } | |
3435 | |
3436 | |
3437 | |
3438 static int exp_stricmp(const char* s1, const char* s2) | |
3439 { | |
3440 return strcasecmp(s1, s2); | |
3441 } | |
3442 | |
3443 /* from declaration taken from Wine sources - this fountion seems to be | |
3444 * undocumented in any M$ doc */ | |
3445 static int exp_setjmp3(void* jmpbuf, int x) | |
3446 { | |
3447 //dbgprintf("!!!!UNIMPLEMENTED: setjmp3(%p, %d) => 0\n", jmpbuf, x); | |
3448 //return 0; | |
3449 __asm__ __volatile__ | |
3450 ( | |
3451 //"mov 4(%%esp), %%edx \n\t" | |
3452 "mov (%%esp), %%eax \n\t" | |
3453 "mov %%eax, (%%edx) \n\t" // store ebp | |
3454 | |
3455 //"mov %%ebp, (%%edx) \n\t" | |
3456 "mov %%ebx, 4(%%edx) \n\t" | |
3457 "mov %%edi, 8(%%edx) \n\t" | |
3458 "mov %%esi, 12(%%edx) \n\t" | |
3459 "mov %%esp, 16(%%edx) \n\t" | |
3460 | |
3461 "mov 4(%%esp), %%eax \n\t" | |
3462 "mov %%eax, 20(%%edx) \n\t" | |
3463 | |
3464 "movl $0x56433230, 32(%%edx) \n\t" // VC20 ?? | |
3465 "movl $0, 36(%%edx) \n\t" | |
3466 : // output | |
3467 : "d"(jmpbuf) // input | |
3468 ); | |
3469 #if 1 | |
3470 __asm__ __volatile__ | |
3471 ( | |
3472 "mov %%fs:0, %%eax \n\t" // unsure | |
3473 "mov %%eax, 24(%%edx) \n\t" | |
3474 "cmp $0xffffffff, %%eax \n\t" | |
3475 "jnz l1 \n\t" | |
3476 "mov %%eax, 28(%%edx) \n\t" | |
3477 "l1: \n\t" | |
3478 : | |
3479 : | |
3480 ); | |
3481 #endif | |
3482 | |
3483 return 0; | |
3484 } | |
3485 | |
3486 | |
2779 | 3487 |
1 | 3488 struct exports |
3489 { | |
3490 char name[64]; | |
3491 int id; | |
3492 void* func; | |
3493 }; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3494 struct libs |
1 | 3495 { |
3496 char name[64]; | |
3497 int length; | |
3498 struct exports* exps; | |
3499 }; | |
3500 | |
3501 #define FF(X,Y) \ | |
3465 | 3502 {#X, Y, (void*)exp##X}, |
3503 | |
3504 struct exports exp_kernel32[]= | |
3505 { | |
3506 FF(IsBadWritePtr, 357) | |
3507 FF(IsBadReadPtr, 354) | |
3508 FF(IsBadStringPtrW, -1) | |
3509 FF(IsBadStringPtrA, -1) | |
3510 FF(DisableThreadLibraryCalls, -1) | |
3511 FF(CreateThread, -1) | |
3512 FF(CreateEventA, -1) | |
3513 FF(SetEvent, -1) | |
3514 FF(ResetEvent, -1) | |
3515 FF(WaitForSingleObject, -1) | |
3516 FF(GetSystemInfo, -1) | |
3517 FF(GetVersion, 332) | |
3518 FF(HeapCreate, 461) | |
3519 FF(HeapAlloc, -1) | |
3520 FF(HeapDestroy, -1) | |
3521 FF(HeapFree, -1) | |
3522 FF(HeapSize, -1) | |
3523 FF(HeapReAlloc,-1) | |
3524 FF(GetProcessHeap, -1) | |
3525 FF(VirtualAlloc, -1) | |
3526 FF(VirtualFree, -1) | |
3527 FF(InitializeCriticalSection, -1) | |
3528 FF(EnterCriticalSection, -1) | |
3529 FF(LeaveCriticalSection, -1) | |
3530 FF(DeleteCriticalSection, -1) | |
3531 FF(TlsAlloc, -1) | |
3532 FF(TlsFree, -1) | |
3533 FF(TlsGetValue, -1) | |
3534 FF(TlsSetValue, -1) | |
3535 FF(GetCurrentThreadId, -1) | |
3536 FF(GetCurrentProcess, -1) | |
3537 FF(LocalAlloc, -1) | |
3538 FF(LocalReAlloc,-1) | |
3539 FF(LocalLock, -1) | |
3540 FF(GlobalAlloc, -1) | |
3541 FF(GlobalReAlloc, -1) | |
3542 FF(GlobalLock, -1) | |
3543 FF(GlobalSize, -1) | |
3544 FF(MultiByteToWideChar, 427) | |
3545 FF(WideCharToMultiByte, -1) | |
3546 FF(GetVersionExA, -1) | |
3547 FF(CreateSemaphoreA, -1) | |
3548 FF(QueryPerformanceCounter, -1) | |
3549 FF(QueryPerformanceFrequency, -1) | |
3550 FF(LocalHandle, -1) | |
3551 FF(LocalUnlock, -1) | |
3552 FF(LocalFree, -1) | |
3553 FF(GlobalHandle, -1) | |
3554 FF(GlobalUnlock, -1) | |
3555 FF(GlobalFree, -1) | |
3556 FF(LoadResource, -1) | |
3557 FF(ReleaseSemaphore, -1) | |
3558 FF(FindResourceA, -1) | |
3559 FF(LockResource, -1) | |
3560 FF(FreeResource, -1) | |
3561 FF(SizeofResource, -1) | |
3562 FF(CloseHandle, -1) | |
3563 FF(GetCommandLineA, -1) | |
3564 FF(GetEnvironmentStringsW, -1) | |
3565 FF(FreeEnvironmentStringsW, -1) | |
3566 FF(FreeEnvironmentStringsA, -1) | |
3567 FF(GetEnvironmentStrings, -1) | |
3568 FF(GetStartupInfoA, -1) | |
3569 FF(GetStdHandle, -1) | |
3570 FF(GetFileType, -1) | |
3571 FF(SetHandleCount, -1) | |
3572 FF(GetACP, -1) | |
3573 FF(GetModuleFileNameA, -1) | |
3574 FF(SetUnhandledExceptionFilter, -1) | |
3575 FF(LoadLibraryA, -1) | |
3576 FF(GetProcAddress, -1) | |
3577 FF(FreeLibrary, -1) | |
3578 FF(CreateFileMappingA, -1) | |
3579 FF(OpenFileMappingA, -1) | |
3580 FF(MapViewOfFile, -1) | |
3581 FF(UnmapViewOfFile, -1) | |
3582 FF(Sleep, -1) | |
3583 FF(GetModuleHandleA, -1) | |
3584 FF(GetProfileIntA, -1) | |
3585 FF(GetPrivateProfileIntA, -1) | |
3586 FF(GetPrivateProfileStringA, -1) | |
3587 FF(WritePrivateProfileStringA, -1) | |
3588 FF(GetLastError, -1) | |
3589 FF(SetLastError, -1) | |
3590 FF(InterlockedIncrement, -1) | |
3591 FF(InterlockedDecrement, -1) | |
3592 FF(GetTimeZoneInformation, -1) | |
3593 FF(OutputDebugStringA, -1) | |
3594 FF(GetLocalTime, -1) | |
3595 FF(GetSystemTime, -1) | |
3596 FF(GetEnvironmentVariableA, -1) | |
3597 FF(RtlZeroMemory,-1) | |
3598 FF(RtlMoveMemory,-1) | |
3599 FF(RtlFillMemory,-1) | |
3600 FF(GetTempPathA,-1) | |
3601 FF(FindFirstFileA,-1) | |
3602 FF(FindNextFileA,-1) | |
3603 FF(FindClose,-1) | |
3604 FF(FileTimeToLocalFileTime,-1) | |
3605 FF(DeleteFileA,-1) | |
3606 FF(ReadFile,-1) | |
3607 FF(WriteFile,-1) | |
3608 FF(SetFilePointer,-1) | |
3609 FF(GetTempFileNameA,-1) | |
3610 FF(CreateFileA,-1) | |
3611 FF(GetSystemDirectoryA,-1) | |
3612 FF(GetWindowsDirectoryA,-1) | |
3613 FF(SetErrorMode, -1) | |
3614 FF(IsProcessorFeaturePresent, -1) | |
3615 FF(GetProcessAffinityMask, -1) | |
3616 FF(InterlockedExchange, -1) | |
3617 FF(MulDiv, -1) | |
3618 FF(lstrcmpiA, -1) | |
3619 FF(lstrlenA, -1) | |
3620 FF(lstrcpyA, -1) | |
3621 FF(lstrcatA, -1) | |
3622 FF(lstrcpynA,-1) | |
3623 FF(GetProcessVersion,-1) | |
3624 FF(GetCurrentThread,-1) | |
3625 FF(GetOEMCP,-1) | |
3626 FF(GetCPInfo,-1) | |
3627 FF(DuplicateHandle,-1) | |
3628 FF(GetTickCount, -1) | |
3629 FF(SetThreadAffinityMask,-1) | |
1 | 3630 }; |
3631 | |
3632 struct exports exp_msvcrt[]={ | |
3465 | 3633 FF(malloc, -1) |
3634 FF(_initterm, -1) | |
3635 FF(free, -1) | |
3636 {"??3@YAXPAX@Z", -1, expdelete}, | |
3637 {"??2@YAPAXI@Z", -1, expnew}, | |
3638 {"_adjust_fdiv", -1, (void*)&_adjust_fdiv}, | |
3639 FF(strrchr, -1) | |
3640 FF(strchr, -1) | |
3641 FF(strlen, -1) | |
3642 FF(strcpy, -1) | |
3643 FF(wcscpy, -1) | |
3644 FF(strcmp, -1) | |
3645 FF(strncmp, -1) | |
3646 FF(strcat, -1) | |
3647 FF(_stricmp,-1) | |
3648 FF(_strdup,-1) | |
3649 FF(_setjmp3,-1) | |
3650 FF(isalnum, -1) | |
3672
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3651 FF(isspace, -1) |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3652 FF(isalpha, -1) |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3653 FF(isdigit, -1) |
3465 | 3654 FF(memmove, -1) |
3655 FF(memcmp, -1) | |
3672
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3656 FF(memset, -1) |
1d48df12001b
fixes for vdub plugin support - by Fredrik Kuivinen <freku045@student.liu.se>
arpi
parents:
3547
diff
changeset
|
3657 FF(memcpy, -1) |
3465 | 3658 FF(time, -1) |
3659 FF(rand, -1) | |
3660 FF(srand, -1) | |
3661 FF(log10, -1) | |
3662 FF(pow, -1) | |
3663 FF(cos, -1) | |
3664 FF(_ftol,-1) | |
3665 FF(sprintf,-1) | |
3666 FF(sscanf,-1) | |
3667 FF(fopen,-1) | |
3668 FF(fprintf,-1) | |
3669 FF(printf,-1) | |
3670 FF(getenv,-1) | |
1 | 3671 }; |
3672 struct exports exp_winmm[]={ | |
3465 | 3673 FF(GetDriverModuleHandle, -1) |
3674 FF(timeGetTime, -1) | |
3675 FF(DefDriverProc, -1) | |
3676 FF(OpenDriverA, -1) | |
3677 FF(OpenDriver, -1) | |
1 | 3678 }; |
3679 struct exports exp_user32[]={ | |
3465 | 3680 FF(LoadStringA, -1) |
3681 FF(wsprintfA, -1) | |
3682 FF(GetDC, -1) | |
3683 FF(GetDesktopWindow, -1) | |
3684 FF(ReleaseDC, -1) | |
3685 FF(IsRectEmpty, -1) | |
3686 FF(LoadCursorA,-1) | |
3687 FF(SetCursor,-1) | |
3688 FF(GetCursorPos,-1) | |
3689 FF(GetCursorPos,-1) | |
3690 FF(RegisterWindowMessageA,-1) | |
3691 FF(GetSystemMetrics,-1) | |
3692 FF(GetSysColor,-1) | |
3693 FF(GetSysColorBrush,-1) | |
3694 FF(GetWindowDC, -1) | |
3695 FF(DrawTextA, -1) | |
1 | 3696 }; |
3697 struct exports exp_advapi32[]={ | |
3465 | 3698 FF(RegCloseKey, -1) |
3699 FF(RegCreateKeyExA, -1) | |
3700 FF(RegEnumKeyExA, -1) | |
3701 FF(RegEnumValueA, -1) | |
3702 FF(RegOpenKeyA, -1) | |
3703 FF(RegOpenKeyExA, -1) | |
3704 FF(RegQueryValueExA, -1) | |
3705 FF(RegSetValueExA, -1) | |
1 | 3706 }; |
3707 struct exports exp_gdi32[]={ | |
3465 | 3708 FF(CreateCompatibleDC, -1) |
3709 FF(CreateFontA, -1) | |
3710 FF(DeleteDC, -1) | |
3711 FF(DeleteObject, -1) | |
3712 FF(GetDeviceCaps, -1) | |
3713 FF(GetSystemPaletteEntries, -1) | |
1 | 3714 }; |
3715 struct exports exp_version[]={ | |
3465 | 3716 FF(GetFileVersionInfoSizeA, -1) |
1 | 3717 }; |
128 | 3718 struct exports exp_ole32[]={ |
3465 | 3719 FF(CoCreateFreeThreadedMarshaler,-1) |
3720 FF(CoCreateInstance, -1) | |
3721 FF(CoInitialize, -1) | |
3722 FF(CoTaskMemAlloc, -1) | |
3723 FF(CoTaskMemFree, -1) | |
3724 FF(StringFromGUID2, -1) | |
128 | 3725 }; |
3465 | 3726 // do we really need crtdll ??? |
3727 // msvcrt is the correct place probably... | |
130 | 3728 struct exports exp_crtdll[]={ |
3465 | 3729 FF(memcpy, -1) |
3730 FF(wcscpy, -1) | |
130 | 3731 }; |
2069 | 3732 struct exports exp_comctl32[]={ |
3465 | 3733 FF(StringFromGUID2, -1) |
3734 FF(InitCommonControls, 17) | |
2069 | 3735 }; |
3465 | 3736 |
3737 struct exports exp_msdmo[]={ | |
3738 FF(memcpy, -1) // just test | |
3739 }; | |
3740 | |
1 | 3741 #define LL(X) \ |
3465 | 3742 {#X".dll", sizeof(exp_##X)/sizeof(struct exports), exp_##X}, |
1 | 3743 |
3744 struct libs libraries[]={ | |
3465 | 3745 LL(kernel32) |
3746 LL(msvcrt) | |
3747 LL(winmm) | |
3748 LL(user32) | |
3749 LL(advapi32) | |
3750 LL(gdi32) | |
3751 LL(version) | |
3752 LL(ole32) | |
3753 LL(crtdll) | |
3754 LL(comctl32) | |
3755 LL(msdmo) | |
1 | 3756 }; |
3757 | |
3465 | 3758 static char* called_unk = "Called unk_%s\n"; |
3759 static void ext_stubs(void) | |
3760 { | |
3761 // expects: | |
3762 // ax position index | |
3763 // cx address of printf function | |
3764 __asm__ __volatile__ | |
3765 ( | |
3766 "push %edx \n\t" | |
3767 "movl $0, %eax \n\t" | |
3768 "movl $0, %edx \n\t" | |
3769 "shl $5,%eax \n\t" // ax * 32 | |
3770 "addl $export_names,%eax \n\t" | |
3771 "pushl %eax \n\t" | |
3772 "pushl called_unk \n\t" | |
3773 "call *%edx \n\t" // printf (via dx) | |
3774 "addl $8,%esp \n\t" | |
3775 "xorl %eax,%eax \n\t" | |
3776 "pop %edx \n\t" | |
3777 ); | |
3778 } | |
3779 | |
3780 //static void add_stub(int pos) | |
3781 | |
3782 extern int unk_exp1; | |
3783 static char extcode[20000];// place for 200 unresolved exports | |
3784 static int pos=0; | |
3785 | |
3786 static void* add_stub() | |
3787 { | |
3788 char* answ = (char*)extcode+pos*0x30; | |
3789 #if 0 | |
3790 memcpy(answ, &unk_exp1, 0x64); | |
3791 *(int*)(answ+9)=pos; | |
3792 *(int*)(answ+47)-=((int)answ-(int)&unk_exp1); | |
3793 #endif | |
3794 memcpy(answ, ext_stubs, 0x2f); // 0x2c is current size | |
3795 //answ[0] = 0xb8; // movl $0, eax (0xb8 0x00000000) | |
3796 *((int*) (answ + 5)) = pos; | |
3797 //answ[5] = 0xb9; // movl $0, edx (0xb9 0x00000000) | |
3798 *((int*) (answ + 10)) = (int) printf; | |
3799 pos++; | |
3800 return (void*)answ; | |
3801 } | |
2069 | 3802 |
1 | 3803 void* LookupExternal(const char* library, int ordinal) |
3804 { | |
3805 int i,j; | |
3806 if(library==0) | |
3807 { | |
3808 printf("ERROR: library=0\n"); | |
3809 return (void*)ext_unknown; | |
3810 } | |
3465 | 3811 // printf("%x %x\n", &unk_exp1, &unk_exp2); |
1 | 3812 |
3813 for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++) | |
3814 { | |
3815 if(strcasecmp(library, libraries[i].name)) | |
3816 continue; | |
3817 for(j=0; j<libraries[i].length; j++) | |
3818 { | |
3819 if(ordinal!=libraries[i].exps[j].id) | |
3820 continue; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3821 //printf("Hit: 0x%p\n", libraries[i].exps[j].func); |
1 | 3822 return libraries[i].exps[j].func; |
3823 } | |
3824 } | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3825 printf("External func %s:%d\n", library, ordinal); |
1 | 3826 if(pos>150)return 0; |
3827 sprintf(export_names[pos], "%s:%d", library, ordinal); | |
3465 | 3828 return add_stub(pos); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3829 } |
1 | 3830 |
3831 void* LookupExternalByName(const char* library, const char* name) | |
3832 { | |
3833 char* answ; | |
3834 int i,j; | |
3465 | 3835 // return (void*)ext_unknown; |
1 | 3836 if(library==0) |
3837 { | |
3838 printf("ERROR: library=0\n"); | |
3839 return (void*)ext_unknown; | |
3840 } | |
3841 if(name==0) | |
3842 { | |
3843 printf("ERROR: name=0\n"); | |
3844 return (void*)ext_unknown; | |
3845 } | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3846 //printf("External func %s:%s\n", library, name); |
1 | 3847 for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++) |
3848 { | |
3849 if(strcasecmp(library, libraries[i].name)) | |
3850 continue; | |
3851 for(j=0; j<libraries[i].length; j++) | |
3852 { | |
3853 if(strcmp(name, libraries[i].exps[j].name)) | |
3854 continue; | |
3465 | 3855 // printf("Hit: 0x%08X\n", libraries[i].exps[j].func); |
1 | 3856 return libraries[i].exps[j].func; |
3857 } | |
3858 } | |
3465 | 3859 if(pos>150)return 0;// to many symbols |
1 | 3860 strcpy(export_names[pos], name); |
3465 | 3861 return add_stub(pos); |
1 | 3862 } |
3863 | |
2069 | 3864 void my_garbagecollection(void) |
128 | 3865 { |
3866 #ifdef GARBAGE | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3867 int unfree = 0, unfreecnt = 0; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3868 |
3134 | 3869 free_registry(); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3870 while (last_alloc) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3871 { |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3872 alloc_header* mem = last_alloc + 1; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3873 unfree += my_size(mem); |
3465 | 3874 unfreecnt++; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3875 my_release(mem); |
128 | 3876 } |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2579
diff
changeset
|
3877 printf("Total Unfree %d bytes cnt %d [%p,%d]\n",unfree, unfreecnt, last_alloc, alccnt); |
128 | 3878 #endif |
3134 | 3879 g_tls = NULL; |
3880 list = NULL; | |
128 | 3881 } |