Mercurial > mplayer.hg

comparison loader/ext.c @ 2069:ce45cce7f7a5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
sync with avifile
author arpi
date Thu, 04 Oct 2001 02:21:47 +0000
parents d8c1b0b38edc
children 958d10763c34
comparison
equal deleted inserted replaced
2068:3189c317dfc1 2069:ce45cce7f7a5
65 return calloc(size, 1); 65 return calloc(size, 1);
66 else 66 else
67 return malloc(size); 67 return malloc(size);
68 } 68 }
69 69
70 WIN_BOOL WINAPI HeapFree(HANDLE heap, DWORD flags,LPVOID mem) 70 WIN_BOOL WINAPI HeapFree(HANDLE heap, DWORD flags, LPVOID mem)
71 { 71 {
72 if (mem) free(mem); 72 if (mem) free(mem);
73 return 1; 73 return 1;
74 } 74 }
75 75
80 return last_error; 80 return last_error;
81 } 81 }
82 82
83 VOID WINAPI SetLastError(DWORD error) 83 VOID WINAPI SetLastError(DWORD error)
84 { 84 {
85 last_error = error; 85 last_error=error;
86 } 86 }
87 87
88 WIN_BOOL WINAPI ReadFile(HANDLE handle,LPVOID mem, DWORD size, LPDWORD result, LPOVERLAPPED flags) 88 WIN_BOOL WINAPI ReadFile(HANDLE handle, LPVOID mem, DWORD size, LPDWORD result, LPOVERLAPPED flags)
89 { 89 {
90 *result=read(handle, mem, size); 90 *result=read(handle, mem, size);
91 return *result; 91 return *result;
92 } 92 }
93 int WINAPI lstrcmpiA(const char* c1, const char* c2) 93 INT WINAPI lstrcmpiA(LPCSTR c1, LPCSTR c2)
94 { 94 {
95 return strcasecmp(c1,c2); 95 return strcasecmp(c1,c2);
96 } 96 }
97 LPSTR WINAPI lstrcpynA(LPSTR dest, LPCSTR src, INT num) 97 LPSTR WINAPI lstrcpynA(LPSTR dest, LPCSTR src, INT num)
98 { 98 {
99 return strncpy(dest,src,num); 99 return strncpy(dest,src,num);
100 } 100 }
101 int WINAPI lstrlenA(const char* s) 101 INT WINAPI lstrlenA(LPCSTR s)
102 { 102 {
103 return strlen(s); 103 return strlen(s);
104 } 104 }
105 INT WINAPI lstrlenW(LPCWSTR s) 105 INT WINAPI lstrlenW(LPCWSTR s)
106 { 106 {
112 l++; 112 l++;
113 return l; 113 return l;
114 } 114 }
115 LPSTR WINAPI lstrcpynWtoA(LPSTR dest, LPCWSTR src, INT count) 115 LPSTR WINAPI lstrcpynWtoA(LPSTR dest, LPCWSTR src, INT count)
116 { 116 {
117 LPSTR rval = dest; 117 LPSTR result = dest;
118 int moved=0; 118 int moved=0;
119 if((dest==0) || (src==0)) 119 if((dest==0) || (src==0))
120 return 0; 120 return 0;
121 while(moved<count) 121 while(moved<count)
122 { 122 {
125 if(*src==0) 125 if(*src==0)
126 break; 126 break;
127 src++; 127 src++;
128 dest++; 128 dest++;
129 } 129 }
130 return rval; 130 return result;
131 } 131 }
132 int wcsnicmp(const unsigned short* s1, const unsigned short* s2, int n) 132 int wcsnicmp(const unsigned short* s1, const unsigned short* s2, int n)
133 { 133 {
134 /*
134 if(s1==0) 135 if(s1==0)
135 return; 136 return;
136 if(s2==0) 137 if(s2==0)
137 return; 138 return;
139 */
138 while(n>0) 140 while(n>0)
139 { 141 {
140 if(*s1<*s2) 142 if(*s1<*s2)
141 return -1; 143 return -1;
142 else 144 else
307 struct file_mapping_s; 309 struct file_mapping_s;
308 typedef struct file_mapping_s 310 typedef struct file_mapping_s
309 { 311 {
310 int mapping_size; 312 int mapping_size;
311 char* name; 313 char* name;
312 HANDLE handle; 314 LPVOID handle;
313 struct file_mapping_s* next; 315 struct file_mapping_s* next;
314 struct file_mapping_s* prev; 316 struct file_mapping_s* prev;
315 }file_mapping; 317 }file_mapping;
316 static file_mapping* fm=0; 318 static file_mapping* fm=0;
317 319
333 DWORD dwMaxHigh, DWORD dwMaxLow, 335 DWORD dwMaxHigh, DWORD dwMaxLow,
334 LPCSTR name) 336 LPCSTR name)
335 { 337 {
336 int hFile = (int)handle; 338 int hFile = (int)handle;
337 unsigned int len; 339 unsigned int len;
338 HANDLE answer; 340 LPVOID answer;
339 int anon=0; 341 int anon=0;
340 int mmap_access=0; 342 int mmap_access=0;
341 if(hFile<0) 343 if(hFile<0)
342 { 344 {
343 anon=1; 345 anon=1;
355 if(flProtect & PAGE_READONLY) 357 if(flProtect & PAGE_READONLY)
356 mmap_access |=PROT_READ; 358 mmap_access |=PROT_READ;
357 else 359 else
358 mmap_access |=PROT_READ|PROT_WRITE; 360 mmap_access |=PROT_READ|PROT_WRITE;
359 361
360 answer=(HANDLE)mmap(NULL, len, mmap_access, MAP_PRIVATE, hFile, 0); 362 answer=mmap(NULL, len, mmap_access, MAP_PRIVATE, hFile, 0);
361 if(anon) 363 if(anon)
362 close(hFile); 364 close(hFile);
363 if(answer!=(HANDLE)-1) 365 if(answer!=(LPVOID)-1)
364 { 366 {
365 if(fm==0) 367 if(fm==0)
366 { 368 {
367 fm=malloc(sizeof(file_mapping)); 369 fm=malloc(sizeof(file_mapping));
368 fm->prev=NULL; 370 fm->prev=NULL;
384 fm->name=NULL; 386 fm->name=NULL;
385 fm->mapping_size=len; 387 fm->mapping_size=len;
386 388
387 if(anon) 389 if(anon)
388 close(hFile); 390 close(hFile);
389 return answer; 391 return (HANDLE)answer;
390 } 392 }
391 return (HANDLE)0; 393 return (HANDLE)0;
392 } 394 }
393 WIN_BOOL WINAPI UnmapViewOfFile(LPVOID handle) 395 WIN_BOOL WINAPI UnmapViewOfFile(LPVOID handle)
394 { 396 {
395 file_mapping* p; 397 file_mapping* p;
396 int result; 398 int result;
397 if(fm==0) 399 if(fm==0)
398 return (HANDLE)0; 400 return 0;
399 for(p=fm; p; p=p->next) 401 for(p=fm; p; p=p->next)
400 { 402 {
401 if(p->handle==(HANDLE)handle) 403 if(p->handle==handle)
402 { 404 {
403 result=munmap((void*)handle, p->mapping_size); 405 result=munmap((void*)handle, p->mapping_size);
404 if(p->next)p->next->prev=p->prev; 406 if(p->next)p->next->prev=p->prev;
405 if(p->prev)p->prev->next=p->next; 407 if(p->prev)p->prev->next=p->next;
406 if(p->name) 408 if(p->name)
425 }virt_alloc; 427 }virt_alloc;
426 static virt_alloc* vm=0; 428 static virt_alloc* vm=0;
427 #define MEM_COMMIT 0x00001000 429 #define MEM_COMMIT 0x00001000
428 #define MEM_RESERVE 0x00002000 430 #define MEM_RESERVE 0x00002000
429 431
430 void* WINAPI VirtualAlloc(void* address, DWORD size, DWORD type, DWORD protection) 432 LPVOID WINAPI VirtualAlloc(LPVOID address, DWORD size, DWORD type, DWORD protection)
431 { 433 {
432 void* answer; 434 void* answer;
433 int fd=open("/dev/zero", O_RDWR); 435 int fd=open("/dev/zero", O_RDWR);
434 size=(size+0xffff)&(~0xffff); 436 size=(size+0xffff)&(~0xffff);
435 // printf("VirtualAlloc(0x%08X, %d)\n", address 437 // printf("VirtualAlloc(0x%08X, %d)\n", address
472 // PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE); 474 // PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
473 close(fd); 475 close(fd);
474 if(answer==(void*)-1) 476 if(answer==(void*)-1)
475 { 477 {
476 printf("Error no %d\n", errno); 478 printf("Error no %d\n", errno);
477 printf("VirtualAlloc(0x%08X, %d) failed\n", address, size); 479 printf("VirtualAlloc(0x%p, %ld) failed\n", address, size);
478 return NULL; 480 return NULL;
479 } 481 }
480 else 482 else
481 { 483 {
482 virt_alloc *new_vm=malloc(sizeof(virt_alloc)); 484 virt_alloc *new_vm=malloc(sizeof(virt_alloc));
495 // printf("Multiple VirtualAlloc!\n"); 497 // printf("Multiple VirtualAlloc!\n");
496 // printf("answer=0x%08x\n", answer); 498 // printf("answer=0x%08x\n", answer);
497 return answer; 499 return answer;
498 } 500 }
499 } 501 }
500 WIN_BOOL WINAPI VirtualFree(LPVOID address, DWORD t1, DWORD t2)//not sure 502 WIN_BOOL WINAPI VirtualFree(LPVOID address, DWORD t1, DWORD t2)//not sure
501 { 503 {
502 virt_alloc* str=vm; 504 virt_alloc* str=vm;
503 int answer; 505 int answer;
504 while(str) 506 while(str)
505 { 507 {
516 return 0; 518 return 0;
517 } 519 }
518 return -1; 520 return -1;
519 } 521 }
520 522
521 INT WINAPI WideCharToMultiByte(UINT codepage, DWORD flags, 523 INT WINAPI WideCharToMultiByte(UINT codepage, DWORD flags, LPCWSTR src,
522 LPCWSTR src, INT srclen, 524 INT srclen,LPSTR dest, INT destlen, LPCSTR defch, WIN_BOOL* used_defch)
523 LPSTR dest, INT destlen,
524 LPCSTR defch, WIN_BOOL*used_defch)
525 { 525 {
526 int i; 526 int i;
527 if(src==0) 527 if(src==0)
528 return 0; 528 return 0;
529 if ((srclen==-1)&&(dest==0)) return 0;
529 if(srclen==-1){srclen=0; while(src[srclen++]);} 530 if(srclen==-1){srclen=0; while(src[srclen++]);}
530 // for(i=0; i<srclen; i++) 531 // for(i=0; i<srclen; i++)
531 // printf("%c", src[i]); 532 // printf("%c", src[i]);
532 // printf("\n"); 533 // printf("\n");
533 if(dest==0) 534 if(dest==0)
550 if(*src==0) 551 if(*src==0)
551 return i+1; 552 return i+1;
552 } 553 }
553 return min(srclen, destlen); 554 return min(srclen, destlen);
554 } 555 }
555 INT WINAPI MultiByteToWideChar(UINT codepage, DWORD flags, 556 INT WINAPI MultiByteToWideChar(UINT codepage,DWORD flags, LPCSTR src, INT srclen,
556 LPCSTR src, INT srclen, 557 LPWSTR dest, INT destlen)
557 LPWSTR dest, INT destlen)
558 { 558 {
559 return 0; 559 return 0;
560 } 560 }
561 HANDLE WINAPI OpenFileMappingA(DWORD access, WIN_BOOL prot, LPCSTR name) 561 HANDLE WINAPI OpenFileMappingA(DWORD access, WIN_BOOL prot, LPCSTR name)
562 { 562 {
568 for(p=fm; p; p=p->prev) 568 for(p=fm; p; p=p->prev)
569 { 569 {
570 if(p->name==0) 570 if(p->name==0)
571 continue; 571 continue;
572 if(strcmp(p->name, name)==0) 572 if(strcmp(p->name, name)==0)
573 return p->handle; 573 return (HANDLE)p->handle;
574 } 574 }
575 return 0; 575 return 0;
576 } 576 }