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