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