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