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