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