loader/module.c

   1 /*
   2  * Modules
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  *
   6  * Modified for use with MPlayer, detailed changelog at
   7  * http://svn.mplayerhq.hu/mplayer/trunk/
   8  *
   9  */
  10
  11 // define for quicktime calls debugging and/or MacOS-level emulation:
  12 #ifndef __APPLE__
  13 #define EMU_QTX_API
  14 #endif /* __APPLE__ */
  15
  16 // define for quicktime debugging (verbose logging):
  17 //#define DEBUG_QTX_API
  18
  19 #include "config.h"
  20 #include "debug.h"
  21
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #ifdef HAVE_SYS_MMAN_H
  30 #include <sys/mman.h>
  31 #endif
  32 #include <inttypes.h>
  33
  34 #include "wine/windef.h"
  35 #include "wine/winerror.h"
  36 #include "wine/heap.h"
  37 #include "wine/module.h"
  38 #include "wine/pe_image.h"
  39 #include "wine/debugtools.h"
  40
  41 #undef HAVE_LIBDL
  42
  43 #ifdef HAVE_LIBDL
  44 #include <dlfcn.h>
  45 #include "wine/elfdll.h"
  46 #endif
  47 #include "win32.h"
  48 #include "drv.h"
  49
  50 #ifdef EMU_QTX_API
  51 #include "wrapper.h"
  52 static int report_func(void *stack_base, int stack_size, reg386_t *reg, uint32_t *flags);
  53 static int report_func_ret(void *stack_base, int stack_size, reg386_t *reg, uint32_t *flags);
  54 #endif
  55
  56 //#undef TRACE
  57 //#define TRACE printf
  58
  59 //WINE_MODREF *local_wm=NULL;
  60 modref_list* local_wm=NULL;
  61
  62 HANDLE SegptrHeap;
  63
  64 WINE_MODREF* MODULE_FindModule(LPCSTR m)
  65 {
  66     modref_list* list=local_wm;
  67     TRACE("FindModule: Module %s request\n", m);
  68     if(list==NULL)
  69         return NULL;
  70 //    while(strcmp(m, list->wm->filename))
  71     while(!strstr(list->wm->filename, m))
  72     {
  73         TRACE("%s: %x\n", list->wm->filename, list->wm->module);
  74         list=list->prev;
  75         if(list==NULL)
  76             return NULL;
  77     }
  78     TRACE("Resolved to %s\n", list->wm->filename);
  79     return list->wm;
  80 }
  81
  82 static void MODULE_RemoveFromList(WINE_MODREF *mod)
  83 {
  84     modref_list* list=local_wm;
  85     if(list==0)
  86         return;
  87     if(mod==0)
  88         return;
  89     if((list->prev==NULL)&&(list->next==NULL))
  90     {
  91         free(list);
  92         local_wm=NULL;
  93 //      uninstall_fs();
  94         return;
  95     }
  96     for(;list;list=list->prev)
  97     {
  98         if(list->wm==mod)
  99         {
 100             if(list->prev)
 101                 list->prev->next=list->next;
 102             if(list->next)
 103                 list->next->prev=list->prev;
 104             if(list==local_wm)
 105                 local_wm=list->prev;
 106             free(list);
 107             return;
 108         }
 109     }
 110
 111 }
 112
 113 WINE_MODREF *MODULE32_LookupHMODULE(HMODULE m)
 114 {
 115     modref_list* list=local_wm;
 116     TRACE("LookupHMODULE: Module %X request\n", m);
 117     if(list==NULL)
 118     {
 119         TRACE("LookupHMODULE failed\n");
 120         return NULL;
 121     }
 122     while(m!=list->wm->module)
 123     {
 124 //      printf("Checking list %X wm %X module %X\n",
 125 //      list, list->wm, list->wm->module);
 126         list=list->prev;
 127         if(list==NULL)
 128         {
 129             TRACE("LookupHMODULE failed\n");
 130             return NULL;
 131         }
 132     }
 133     TRACE("LookupHMODULE hit %p\n", list->wm);
 134     return list->wm;
 135 }
 136
 137 /*************************************************************************
 138  *              MODULE_InitDll
 139  */
 140 static WIN_BOOL MODULE_InitDll( WINE_MODREF *wm, DWORD type, LPVOID lpReserved )
 141 {
 142     WIN_BOOL retv = TRUE;
 143
 144     #ifdef DEBUG
 145     static LPCSTR typeName[] = { "PROCESS_DETACH", "PROCESS_ATTACH",
 146                                  "THREAD_ATTACH", "THREAD_DETACH" };
 147     #endif
 148
 149     assert( wm );
 150
 151
 152     /* Skip calls for modules loaded with special load flags */
 153
 154     if (    ( wm->flags & WINE_MODREF_DONT_RESOLVE_REFS )
 155          || ( wm->flags & WINE_MODREF_LOAD_AS_DATAFILE ) )
 156         return TRUE;
 157
 158
 159     TRACE("(%s,%s,%p) - CALL\n", wm->modname, typeName[type], lpReserved );
 160
 161     /* Call the initialization routine */
 162     switch ( wm->type )
 163     {
 164     case MODULE32_PE:
 165         retv = PE_InitDLL( wm, type, lpReserved );
 166         break;
 167
 168     case MODULE32_ELF:
 169         /* no need to do that, dlopen() already does */
 170         break;
 171
 172     default:
 173         ERR("wine_modref type %d not handled.\n", wm->type );
 174         retv = FALSE;
 175         break;
 176     }
 177
 178     /* The state of the module list may have changed due to the call
 179        to PE_InitDLL. We cannot assume that this module has not been
 180        deleted.  */
 181     TRACE("(%p,%s,%p) - RETURN %d\n", wm, typeName[type], lpReserved, retv );
 182
 183     return retv;
 184 }
 185
 186 /*************************************************************************
 187  *              MODULE_DllProcessAttach
 188  *
 189  * Send the process attach notification to all DLLs the given module
 190  * depends on (recursively). This is somewhat complicated due to the fact that
 191  *
 192  * - we have to respect the module dependencies, i.e. modules implicitly
 193  *   referenced by another module have to be initialized before the module
 194  *   itself can be initialized
 195  *
 196  * - the initialization routine of a DLL can itself call LoadLibrary,
 197  *   thereby introducing a whole new set of dependencies (even involving
 198  *   the 'old' modules) at any time during the whole process
 199  *
 200  * (Note that this routine can be recursively entered not only directly
 201  *  from itself, but also via LoadLibrary from one of the called initialization
 202  *  routines.)
 203  *
 204  * Furthermore, we need to rearrange the main WINE_MODREF list to allow
 205  * the process *detach* notifications to be sent in the correct order.
 206  * This must not only take into account module dependencies, but also
 207  * 'hidden' dependencies created by modules calling LoadLibrary in their
 208  * attach notification routine.
 209  *
 210  * The strategy is rather simple: we move a WINE_MODREF to the head of the
 211  * list after the attach notification has returned.  This implies that the
 212  * detach notifications are called in the reverse of the sequence the attach
 213  * notifications *returned*.
 214  *
 215  * NOTE: Assumes that the process critical section is held!
 216  *
 217  */
 218 static WIN_BOOL MODULE_DllProcessAttach( WINE_MODREF *wm, LPVOID lpReserved )
 219 {
 220     WIN_BOOL retv = TRUE;
 221     //int i;
 222     assert( wm );
 223
 224     /* prevent infinite recursion in case of cyclical dependencies */
 225     if (    ( wm->flags & WINE_MODREF_MARKER )
 226          || ( wm->flags & WINE_MODREF_PROCESS_ATTACHED ) )
 227         return retv;
 228
 229     TRACE("(%s,%p) - START\n", wm->modname, lpReserved );
 230
 231     /* Tag current MODREF to prevent recursive loop */
 232     wm->flags |= WINE_MODREF_MARKER;
 233
 234     /* Recursively attach all DLLs this one depends on */
 235 /*    for ( i = 0; retv && i < wm->nDeps; i++ )
 236         if ( wm->deps[i] )
 237             retv = MODULE_DllProcessAttach( wm->deps[i], lpReserved );
 238 */
 239     /* Call DLL entry point */
 240
 241     //local_wm=wm;
 242     if(local_wm)
 243     {
 244         local_wm->next = (modref_list*) malloc(sizeof(modref_list));
 245         local_wm->next->prev=local_wm;
 246         local_wm->next->next=NULL;
 247         local_wm->next->wm=wm;
 248         local_wm=local_wm->next;
 249     }
 250     else
 251     {
 252         local_wm = malloc(sizeof(modref_list));
 253         local_wm->next=local_wm->prev=NULL;
 254         local_wm->wm=wm;
 255     }
 256     /* Remove recursion flag */
 257     wm->flags &= ~WINE_MODREF_MARKER;
 258
 259     if ( retv )
 260     {
 261         retv = MODULE_InitDll( wm, DLL_PROCESS_ATTACH, lpReserved );
 262         if ( retv )
 263             wm->flags |= WINE_MODREF_PROCESS_ATTACHED;
 264     }
 265
 266
 267     TRACE("(%s,%p) - END\n", wm->modname, lpReserved );
 268
 269     return retv;
 270 }
 271
 272 /*************************************************************************
 273  *              MODULE_DllProcessDetach
 274  *
 275  * Send DLL process detach notifications.  See the comment about calling
 276  * sequence at MODULE_DllProcessAttach.  Unless the bForceDetach flag
 277  * is set, only DLLs with zero refcount are notified.
 278  */
 279 static void MODULE_DllProcessDetach( WINE_MODREF* wm, WIN_BOOL bForceDetach, LPVOID lpReserved )
 280 {
 281     //    WINE_MODREF *wm=local_wm;
 282     //modref_list* l = local_wm;
 283     wm->flags &= ~WINE_MODREF_PROCESS_ATTACHED;
 284     MODULE_InitDll( wm, DLL_PROCESS_DETACH, lpReserved );
 285 /*    while (l)
 286     {
 287         modref_list* f = l;
 288         l = l->next;
 289         free(f);
 290     }
 291     local_wm = 0;*/
 292 }
 293
 294 /***********************************************************************
 295  *      MODULE_LoadLibraryExA   (internal)
 296  *
 297  * Load a PE style module according to the load order.
 298  *
 299  * The HFILE parameter is not used and marked reserved in the SDK. I can
 300  * only guess that it should force a file to be mapped, but I rather
 301  * ignore the parameter because it would be extremely difficult to
 302  * integrate this with different types of module represenations.
 303  *
 304  */
 305 static WINE_MODREF *MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD flags )
 306 {
 307         DWORD err = GetLastError();
 308         WINE_MODREF *pwm;
 309 //      module_loadorder_t *plo;
 310
 311         SetLastError( ERROR_FILE_NOT_FOUND );
 312         TRACE("Trying native dll '%s'\n", libname);
 313         pwm = PE_LoadLibraryExA(libname, flags);
 314 #ifdef HAVE_LIBDL
 315         if(!pwm)
 316         {
 317             TRACE("Trying ELF dll '%s'\n", libname);
 318             pwm=(WINE_MODREF*)ELFDLL_LoadLibraryExA(libname, flags);
 319         }
 320 #endif
 321 //              printf("0x%08x\n", pwm);
 322 //              break;
 323         if(pwm)
 324         {
 325                 /* Initialize DLL just loaded */
 326                 TRACE("Loaded module '%s' at 0x%08x, \n", libname, pwm->module);
 327                 /* Set the refCount here so that an attach failure will */
 328                 /* decrement the dependencies through the MODULE_FreeLibrary call. */
 329                 pwm->refCount++;
 330
 331                 SetLastError( err );  /* restore last error */
 332                 return pwm;
 333         }
 334
 335
 336         WARN("Failed to load module '%s'; error=0x%08lx, \n", libname, GetLastError());
 337         return NULL;
 338 }
 339
 340 /***********************************************************************
 341  *           MODULE_FreeLibrary
 342  *
 343  * NOTE: Assumes that the process critical section is held!
 344  */
 345 static WIN_BOOL MODULE_FreeLibrary( WINE_MODREF *wm )
 346 {
 347     TRACE("(%s) - START\n", wm->modname );
 348
 349     /* Recursively decrement reference counts */
 350     //MODULE_DecRefCount( wm );
 351
 352     /* Call process detach notifications */
 353     MODULE_DllProcessDetach( wm, FALSE, NULL );
 354
 355     PE_UnloadLibrary(wm);
 356
 357     TRACE("END\n");
 358
 359     return TRUE;
 360 }
 361
 362 /***********************************************************************
 363  *           LoadLibraryExA   (KERNEL32)
 364  */
 365 HMODULE WINAPI LoadLibraryExA(LPCSTR libname, HANDLE hfile, DWORD flags)
 366 {
 367         WINE_MODREF *wm = 0;
 368         char* listpath[] = { "", "", "/usr/lib/win32", "/usr/local/lib/win32", 0 };
 369         extern char* def_path;
 370         char path[512];
 371         char checked[2000];
 372         int i = -1;
 373
 374         checked[0] = 0;
 375         if(!libname)
 376         {
 377                 SetLastError(ERROR_INVALID_PARAMETER);
 378                 return 0;
 379         }
 380
 381         wm=MODULE_FindModule(libname);
 382         if(wm) return wm->module;
 383
 384 //      if(fs_installed==0)
 385 //          install_fs();
 386
 387         while (wm == 0 && listpath[++i])
 388         {
 389             if (i < 2)
 390             {
 391                 if (i == 0)
 392                     /* check just original file name */
 393                     strncpy(path, libname, 511);
 394                 else
 395                     /* check default user path */
 396                     strncpy(path, def_path, 300);
 397             }
 398             else if (strcmp(def_path, listpath[i]))
 399                 /* path from the list */
 400                 strncpy(path, listpath[i], 300);
 401             else
 402                 continue;
 403
 404             if (i > 0)
 405             {
 406                 strcat(path, "/");
 407                 strncat(path, libname, 100);
 408             }
 409             path[511] = 0;
 410             wm = MODULE_LoadLibraryExA( path, hfile, flags );
 411
 412             if (!wm)
 413             {
 414                 if (checked[0])
 415                     strcat(checked, ", ");
 416                 strcat(checked, path);
 417                 checked[1500] = 0;
 418
 419             }
 420         }
 421         if ( wm )
 422         {
 423                 if ( !MODULE_DllProcessAttach( wm, NULL ) )
 424                 {
 425                         WARN_(module)("Attach failed for module '%s', \n", libname);
 426                         MODULE_FreeLibrary(wm);
 427                         SetLastError(ERROR_DLL_INIT_FAILED);
 428                         MODULE_RemoveFromList(wm);
 429                         wm = NULL;
 430                 }
 431         }
 432
 433         if (!wm && !strstr(checked, "avisynth.dll"))
 434             printf("Win32 LoadLibrary failed to load: %s\n", checked);
 435
 436 #define RVA(x) ((char *)wm->module+(unsigned int)(x))
 437         if (strstr(libname,"vp31vfw.dll") && wm)
 438         {
 439             int i;
 440
 441           // sse hack moved from patch dll into runtime patching
 442           if (PE_FindExportedFunction(wm, "DriverProc", TRUE)==RVA(0x1000)) {
 443             fprintf(stderr, "VP3 DLL found\n");
 444             for (i=0;i<18;i++) RVA(0x4bd6)[i]=0x90;
 445           }
 446         }
 447
 448         // remove a few divs in the VP codecs that make trouble
 449         if (strstr(libname,"vp5vfw.dll") && wm)
 450         {
 451           int i;
 452           if (PE_FindExportedFunction(wm, "DriverProc", TRUE)==RVA(0x3930)) {
 453             for (i=0;i<3;i++) RVA(0x4e86)[i]=0x90;
 454             for (i=0;i<3;i++) RVA(0x5a23)[i]=0x90;
 455             for (i=0;i<3;i++) RVA(0x5bff)[i]=0x90;
 456           } else {
 457             fprintf(stderr, "Unsupported VP5 version\n");
 458             return 0;
 459           }
 460         }
 461
 462         if (strstr(libname,"vp6vfw.dll") && wm)
 463         {
 464           int i;
 465           if (PE_FindExportedFunction(wm, "DriverProc", TRUE)==RVA(0x3ef0)) {
 466             // looks like VP 6.1.0.2
 467             for (i=0;i<6;i++) RVA(0x7268)[i]=0x90;
 468             for (i=0;i<6;i++) RVA(0x7e83)[i]=0x90;
 469             for (i=0;i<6;i++) RVA(0x806a)[i]=0x90;
 470           } else if (PE_FindExportedFunction(wm, "DriverProc", TRUE)==RVA(0x4120)) {
 471             // looks like VP 6.2.0.10
 472             for (i=0;i<6;i++) RVA(0x7688)[i]=0x90;
 473             for (i=0;i<6;i++) RVA(0x82c3)[i]=0x90;
 474             for (i=0;i<6;i++) RVA(0x84aa)[i]=0x90;
 475             for (i=0;i<6;i++) RVA(0x1d2cc)[i]=0x90;
 476             for (i=0;i<6;i++) RVA(0x2179d)[i]=0x90;
 477             for (i=0;i<6;i++) RVA(0x1977f)[i]=0x90;
 478           } else if (PE_FindExportedFunction(wm, "DriverProc", TRUE)==RVA(0x3e70)) {
 479             // looks like VP 6.0.7.3
 480             for (i=0;i<6;i++) RVA(0x7559)[i]=0x90;
 481             for (i=0;i<6;i++) RVA(0x81c3)[i]=0x90;
 482             for (i=0;i<6;i++) RVA(0x839e)[i]=0x90;
 483           } else {
 484             fprintf(stderr, "Unsupported VP6 version\n");
 485             return 0;
 486           }
 487         }
 488
 489         // Windows Media Video 9 Advanced
 490         if (strstr(libname,"wmvadvd.dll") && wm)
 491         {
 492           // The codec calls IsRectEmpty with coords 0,0,0,0 => result is 0
 493           // but it really wants the rectangle to be not empty
 494           if (PE_FindExportedFunction(wm, "CreateInstance", TRUE)==RVA(0xb812)) {
 495             // Dll version is 10.0.0.3645
 496             *RVA(0x8b0f)=0xeb; // Jump always, ignoring IsRectEmpty result
 497           } else {
 498             fprintf(stderr, "Unsupported WMVA version\n");
 499             return 0;
 500           }
 501         }
 502
 503         if (strstr(libname,"QuickTime.qts") && wm)
 504         {
 505             void** ptr;
 506             void *dispatch_addr;
 507             int i;
 508
 509 //          dispatch_addr = GetProcAddress(wm->module, "theQuickTimeDispatcher", TRUE);
 510             dispatch_addr = PE_FindExportedFunction(wm, "theQuickTimeDispatcher", TRUE);
 511             if (dispatch_addr == RVA(0x124c30))
 512             {
 513                 fprintf(stderr, "QuickTime5 DLLs found\n");
 514                 ptr = (void **)RVA(0x375ca4); // dispatch_ptr
 515                 for (i=0;i<5;i++)  RVA(0x19e842)[i]=0x90; // make_new_region ?
 516                 for (i=0;i<28;i++) RVA(0x19e86d)[i]=0x90; // call__call_CreateCompatibleDC ?
 517                 for (i=0;i<5;i++)  RVA(0x19e898)[i]=0x90; // jmp_to_call_loadbitmap ?
 518                 for (i=0;i<9;i++)  RVA(0x19e8ac)[i]=0x90; // call__calls_OLE_shit ?
 519                 for (i=0;i<106;i++) RVA(0x261b10)[i]=0x90; // disable threads
 520 #if 0
 521                 /* CreateThread callers */
 522                 for (i=0;i<5;i++) RVA(0x1487c5)[i]=0x90;
 523                 for (i=0;i<5;i++) RVA(0x14b275)[i]=0x90;
 524                 for (i=0;i<5;i++) RVA(0x1a24b1)[i]=0x90;
 525                 for (i=0;i<5;i++) RVA(0x1afc5a)[i]=0x90;
 526                 for (i=0;i<5;i++) RVA(0x2f799c)[i]=0x90;
 527                 for (i=0;i<5;i++) RVA(0x2f7efe)[i]=0x90;
 528                 for (i=0;i<5;i++) RVA(0x2fa33e)[i]=0x90;
 529 #endif
 530
 531 #if 0
 532                 /* TerminateQTML fix */
 533                 for (i=0;i<47;i++) RVA(0x2fa3b8)[i]=0x90; // terminate thread
 534                 for (i=0;i<47;i++) RVA(0x2f7f78)[i]=0x90; // terminate thread
 535                 for (i=0;i<77;i++) RVA(0x1a13d5)[i]=0x90;
 536                 RVA(0x08e0ae)[0] = 0xc3; // font/dc remover
 537                 for (i=0;i<24;i++) RVA(0x07a1ad)[i]=0x90; // destroy window
 538 #endif
 539             } else if (dispatch_addr == RVA(0x13b330))
 540             {
 541                 fprintf(stderr, "QuickTime6 DLLs found\n");
 542                 ptr = (void **)RVA(0x3b9524); // dispatcher_ptr
 543                 for (i=0;i<5;i++)  RVA(0x2730cc)[i]=0x90; // make_new_region
 544                 for (i=0;i<28;i++) RVA(0x2730f7)[i]=0x90; // call__call_CreateCompatibleDC
 545                 for (i=0;i<5;i++)  RVA(0x273122)[i]=0x90; // jmp_to_call_loadbitmap
 546                 for (i=0;i<9;i++)  RVA(0x273131)[i]=0x90; // call__calls_OLE_shit
 547                 for (i=0;i<96;i++) RVA(0x2ac852)[i]=0x90; // disable threads
 548             } else if (dispatch_addr == RVA(0x13c3e0))
 549             {
 550                 fprintf(stderr, "QuickTime6.3 DLLs found\n");
 551                 ptr = (void **)RVA(0x3ca01c); // dispatcher_ptr
 552                 for (i=0;i<5;i++)  RVA(0x268f6c)[i]=0x90; // make_new_region
 553                 for (i=0;i<28;i++) RVA(0x268f97)[i]=0x90; // call__call_CreateCompatibleDC
 554                 for (i=0;i<5;i++)  RVA(0x268fc2)[i]=0x90; // jmp_to_call_loadbitmap
 555                 for (i=0;i<9;i++)  RVA(0x268fd1)[i]=0x90; // call__calls_OLE_shit
 556                 for (i=0;i<96;i++) RVA(0x2b4722)[i]=0x90; // disable threads
 557             } else
 558             {
 559                 fprintf(stderr, "Unsupported QuickTime version (%p)\n",
 560                     dispatch_addr);
 561                 return 0;
 562             }
 563
 564             fprintf(stderr,"QuickTime.qts patched!!! old entry=%p\n",ptr[0]);
 565
 566 #ifdef EMU_QTX_API
 567             report_entry = report_func;
 568             report_ret   = report_func_ret;
 569             wrapper_target=ptr[0];
 570             ptr[0]=wrapper;
 571 #endif
 572         }
 573 #undef RVA
 574
 575         return wm ? wm->module : 0;
 576 }
 577
 578
 579 /***********************************************************************
 580  *           LoadLibraryA         (KERNEL32)
 581  */
 582 HMODULE WINAPI LoadLibraryA(LPCSTR libname) {
 583         return LoadLibraryExA(libname,0,0);
 584 }
 585
 586 /***********************************************************************
 587  *           FreeLibrary
 588  */
 589 WIN_BOOL WINAPI FreeLibrary(HINSTANCE hLibModule)
 590 {
 591     WIN_BOOL retv = FALSE;
 592     WINE_MODREF *wm;
 593
 594     wm=MODULE32_LookupHMODULE(hLibModule);
 595
 596     if ( !wm || !hLibModule )
 597     {
 598         SetLastError( ERROR_INVALID_HANDLE );
 599         return 0;
 600     }
 601     else
 602         retv = MODULE_FreeLibrary( wm );
 603
 604     MODULE_RemoveFromList(wm);
 605
 606     /* garbage... */
 607     if (local_wm == NULL) my_garbagecollection();
 608
 609     return retv;
 610 }
 611
 612 /***********************************************************************
 613  *           MODULE_DecRefCount
 614  *
 615  * NOTE: Assumes that the process critical section is held!
 616  */
 617 static void MODULE_DecRefCount( WINE_MODREF *wm )
 618 {
 619     int i;
 620
 621     if ( wm->flags & WINE_MODREF_MARKER )
 622         return;
 623
 624     if ( wm->refCount <= 0 )
 625         return;
 626
 627     --wm->refCount;
 628     TRACE("(%s) refCount: %d\n", wm->modname, wm->refCount );
 629
 630     if ( wm->refCount == 0 )
 631     {
 632         wm->flags |= WINE_MODREF_MARKER;
 633
 634         for ( i = 0; i < wm->nDeps; i++ )
 635             if ( wm->deps[i] )
 636                 MODULE_DecRefCount( wm->deps[i] );
 637
 638         wm->flags &= ~WINE_MODREF_MARKER;
 639     }
 640 }
 641
 642 /***********************************************************************
 643  *           GetProcAddress             (KERNEL32.257)
 644  */
 645 FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR function )
 646 {
 647     return MODULE_GetProcAddress( hModule, function, TRUE );
 648 }
 649
 650 #ifdef DEBUG_QTX_API
 651
 652 /*
 653 http://lists.apple.com/archives/quicktime-api/2003/Jan/msg00278.html
 654 */
 655
 656 struct ComponentParameters {
 657     unsigned char                   flags;                      /* call modifiers: sync/async, deferred, immed, etc */
 658     unsigned char                   paramSize;                  /* size in bytes of actual parameters passed to this call */
 659     short                           what;                       /* routine selector, negative for Component management calls */
 660     long                            params[1];                  /* actual parameters for the indicated routine */
 661 };
 662 typedef struct ComponentParameters      ComponentParameters;
 663
 664 static char* component_func(int what){
 665 if (what < 0) // Range 0: Standard Component Calls
 666 switch(what){
 667 case -1: return "kComponentOpenSelect";
 668 case -2: return "kComponentCloseSelect";
 669 case -3: return "kComponentCanDoSelect";
 670 case -4: return "kComponentVersionSelect";
 671 case -5: return "kComponentRegisterSelect";
 672 case -6: return "kComponentTargetSelect";
 673 case -7: return "kComponentUnregisterSelect";
 674 }
 675
 676 if (what >= 0 && what <= 0xff) // Range 1: Generic codecs
 677 switch(what & 0xff){
 678 case 0: return "kImageCodecGetCodecInfoSelect";
 679 case 1: return "kImageCodecGetCompressionTimeSelect";
 680 case 2: return "kImageCodecGetMaxCompressionSizeSelect";
 681 case 3: return "kImageCodecPreCompressSelect";
 682 case 4: return "kImageCodecBandCompressSelect";
 683 case 5: return "kImageCodecPreDecompressSelect";
 684 case 6: return "kImageCodecBandDecompressSelect";
 685 case 7: return "kImageCodecBusySelect";
 686 // finish this list from the above URL
 687 case 0x10: return "kImageCodecIsImageDescriptionEquivalentSelect";
 688 case 0x12: return "kImageCodecDisposeMemorySelect";
 689 case 0x14: return "kImageCodecNewImageBufferMemorySelect";
 690 case 0x28: return "kImageCodecRequestGammaLevelSelect";
 691 }
 692
 693 //if (what >= 0x100 && what <= 0x1ff) // Range 2: Specific to QT Photo JPEG codecs
 694
 695 if (what >= 0x200 && what <= 0x2ff) // Range 3: Base Decompressor
 696 switch(what & 0xff){
 697 case 0: return "Preflight";
 698 case 1: return "Initialize";
 699 case 2: return "BeginBand";
 700 case 3: return "DrawBand";
 701 case 4: return "EndBand";
 702 case 5: return "QueueStarting";
 703 case 6: return "QueueStopping";
 704 }
 705
 706 return "???";
 707 }
 708
 709 static int c_level=0;
 710
 711 static int dump_component(char* name, int type, void* orig, ComponentParameters *params,void** glob){
 712     int ( *orig)(ComponentParameters *params, void** glob) = orig;
 713     int ret,i;
 714
 715     fprintf(stderr,"%*sComponentCall: %s  flags=0x%X  size=%d  what=0x%X %s\n",3*c_level,"",name,params->flags, params->paramSize, params->what, component_func(params->what));
 716
 717     for(i=0;i<params->paramSize/4;i++)
 718         fprintf(stderr,"%*s param[%d] = 0x%X\n",3*c_level,"",i,params->params[i]);
 719
 720     ++c_level;
 721     ret=orig(params,glob);
 722     --c_level;
 723
 724     if(ret>=0x1000)
 725         fprintf(stderr,"%*s return=0x%X\n",3*c_level,"",ret);
 726     else
 727         fprintf(stderr,"%*s return=%d\n",3*c_level,"",ret);
 728     return ret;
 729 }
 730
 731 #define DECL_COMPONENT(sname,name,type) \
 732     static void* real_ ## sname = NULL; \
 733     static int fake_ ## sname(ComponentParameters *params,void** glob){ \
 734         return dump_component(name,type,real_ ## sname, params, glob); \
 735     }
 736
 737 #include "qt_comp.h"
 738
 739 #undef DECL_COMPONENT
 740
 741 #include "qt_fv.h"
 742
 743 #endif
 744
 745 #ifdef EMU_QTX_API
 746
 747 static uint32_t ret_array[4096];
 748 static int ret_i=0;
 749
 750 static int report_func(void *stack_base, int stack_size, reg386_t *reg, uint32_t *flags)
 751 {
 752 #ifdef DEBUG_QTX_API
 753   int i;
 754   int* dptr;
 755   void* pwrapper=NULL;
 756   void* pptr=NULL;
 757   char* pname=NULL;
 758   int plen=-1;
 759   // find the code:
 760
 761   dptr=0x62b67ae0;dptr+=2*((reg->eax>>16)&255);
 762 //  printf("FUNC: flag=%d ptr=%p\n",dptr[0],dptr[1]);
 763   if(dptr[0]&255){
 764       dptr=dptr[1];dptr+=4*(reg->eax&65535);
 765 //      printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",dptr[1],dptr[0],dptr[2]);
 766       pwrapper=dptr[1]; pptr=dptr[0]; plen=dptr[2];
 767   } else {
 768       pwrapper=0x62924910;
 769       switch(dptr[1]){
 770       case 0x629248d0:
 771           dptr=0x62b672c0;dptr+=2*(reg->eax&65535);
 772 //          printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",0x62924910,dptr[0],dptr[1]);
 773           pptr=dptr[0]; plen=dptr[1];
 774           break;
 775       case 0x62924e40:
 776           dptr=0x62b67c70;dptr+=2*(reg->eax&65535);
 777 //          printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",0x62924910,dptr[0],dptr[1]);
 778           pptr=dptr[0]; plen=dptr[1];
 779           break;
 780       case 0x62924e60:
 781           dptr=0x62b68108;if(reg->eax&0x8000) dptr+=2*(reg->eax|0xffff0000); else dptr+=2*(reg->eax&65535);
 782 //          printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",0x62924910,dptr[0],dptr[1]);
 783           pptr=dptr[0]; plen=dptr[1];
 784           break;
 785       case 0x62924e80:
 786           dptr=0x62b68108;if(reg->eax&0x8000) dptr+=2*(reg->eax|0xffff0000); else dptr+=2*(reg->eax&65535);
 787 //          printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",0x62924910,dptr[0],dptr[1]);
 788           pptr=dptr[0]; plen=dptr[1];
 789           break;
 790       default:
 791           printf("FUNC: unknown ptr & psize!\n");
 792           pwrapper=dptr[1];
 793       }
 794   }
 795
 796   for(i=0;qt_fv_list[i].name;i++){
 797           if(qt_fv_list[i].id==reg->eax){
 798               pname=qt_fv_list[i].name;
 799               break;
 800           }
 801   }
 802
 803   printf("FUNC[%X/%s]: wrapper=%p  func=%p  len=%d\n",reg->eax,
 804       pname?pname:"???",pwrapper,pptr,plen);
 805
 806   printf("FUNC: caller=%p  ebx=%p\n",((uint32_t *)stack_base)[0],reg->ebx);
 807
 808   if(pname)
 809       printf("%*sENTER(%d): %s(",ret_i*2,"",ret_i,pname);
 810   else
 811       printf("%*sENTER(%d): %X(",ret_i*2,"",ret_i,reg->eax);
 812   for (i=0;i<plen/4;i++){
 813     unsigned int val=((uint32_t *)stack_base)[1+i];
 814     unsigned char* fcc=&val;
 815     printf("%s0x%X", i?", ":"",val);
 816     if(fcc[0]>=0x20 && fcc[0]<128 &&
 817        fcc[1]>=0x20 && fcc[1]<128 &&
 818        fcc[2]>=0x20 && fcc[2]<128 &&
 819        fcc[3]>=0x20 && fcc[3]<128) printf("='%c%c%c%c'",fcc[3],fcc[2],fcc[1],fcc[0]);
 820     else if(val>=8 && val<65536) printf("=%d",val);
 821   }
 822   printf(")\n");
 823   fflush(stdout);
 824
 825 #endif
 826
 827 #if 1
 828   // emulate some functions:
 829   switch(reg->eax){
 830   // memory management:
 831   case 0x150011: //NewPtrClear
 832   case 0x150012: //NewPtrSysClear
 833       reg->eax=(uint32_t)malloc(((uint32_t *)stack_base)[1]);
 834       memset((void *)reg->eax,0,((uint32_t *)stack_base)[1]);
 835 #ifdef DEBUG_QTX_API
 836       printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
 837 #endif
 838       return 1;
 839   case 0x15000F: //NewPtr
 840   case 0x150010: //NewPtrSys
 841       reg->eax=(uint32_t)malloc(((uint32_t *)stack_base)[1]);
 842 #ifdef DEBUG_QTX_API
 843       printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
 844 #endif
 845       return 1;
 846   case 0x15002f: //DisposePtr
 847       if(((uint32_t *)stack_base)[1]>=0x60000000)
 848           printf("WARNING! Invalid Ptr handle!\n");
 849       else
 850           free((void *)((uint32_t *)stack_base)[1]);
 851       reg->eax=0;
 852 #ifdef DEBUG_QTX_API
 853       printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
 854 #endif
 855       return 1;
 856   // mutexes:
 857   case 0x1d0033: //QTMLCreateMutex
 858       reg->eax=0xdeadbabe;
 859 #ifdef DEBUG_QTX_API
 860       printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
 861 #endif
 862       return 1;
 863   case 0x1d0034: //QTMLDestroyMutex
 864   case 0x1d0035: //QTMLGrabMutex
 865   case 0x1d0036: //QTMLReturnMutex
 866   case 0x1d003d: //QTMLTryGrabMutex
 867       reg->eax=0;
 868 #ifdef DEBUG_QTX_API
 869       printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
 870 #endif
 871       return 1;
 872   }
 873 #endif
 874
 875 #if 0
 876   switch(reg->eax){
 877 //  case 0x00010000:
 878 //      printf("FUNC: ImageCodecInitialize/ImageCodecGetCodecInfo(ci=%p,&icap=%p)\n",((uint32_t *)stack_base)[1],((uint32_t *)stack_base)[4]);
 879 //      break;
 880   case 0x00010003:
 881       printf("FUNC: CountComponents(&desc=%p)\n",((uint32_t *)stack_base)[1]);
 882       break;
 883   case 0x00010004:
 884       printf("FUNC: FindNextComponent(prev=%p,&desc=%p)\n",((uint32_t *)stack_base)[1],((uint32_t *)stack_base)[2]);
 885       break;
 886   case 0x00010007:
 887       printf("FUNC: OpenComponent(prev=%p)\n",((uint32_t *)stack_base)[1]);
 888       break;
 889   case 0x0003008b:
 890       printf("FUNC: QTNewGWorldFromPtr(&pts=%p,fourcc=%.4s,&rect=%p,x1=%p,x2=%p,x3=%p,plane=%p,stride=%d)\n",
 891           ((uint32_t *)stack_base)[1],
 892           &(((uint32_t *)stack_base)[2]),
 893           ((uint32_t *)stack_base)[3],
 894           ((uint32_t *)stack_base)[4],
 895           ((uint32_t *)stack_base)[5],
 896           ((uint32_t *)stack_base)[6],
 897           ((uint32_t *)stack_base)[7],
 898           ((uint32_t *)stack_base)[8]);
 899       break;
 900   case 0x001c0018:
 901       printf("FUNC: GetGWorldPixMap(gworld=%p)\n",((uint32_t *)stack_base)[1]);
 902       break;
 903   case 0x00110001:
 904       printf("FUNC: Gestalt(fourcc=%.4s, &ret=%p)\n",&(((uint32_t *)stack_base)[1]),((uint32_t *)stack_base)[2]);
 905       break;
 906   default: {
 907       int i;
 908       for(i=0;qt_fv_list[i].name;i++){
 909           if(qt_fv_list[i].id==reg->eax){
 910               printf("FUNC: %s\n",qt_fv_list[i].name);
 911               break;
 912           }
 913       }
 914       }
 915   }
 916
 917   // print stack/reg information
 918   printf("ENTER(%d) stack = %d bytes @ %p\n"
 919          "eax = 0x%08x edx = 0x%08x ebx = 0x%08x ecx = 0x%08x\n"
 920          "esp = 0x%08x ebp = 0x%08x esi = 0x%08x edi = 0x%08x\n"
 921          "flags = 0x%08x\n", ret_i,
 922          stack_size, stack_base,
 923          reg->eax, reg->edx, reg->ebx, reg->ecx,
 924          reg->esp, reg->ebp, reg->esi, reg->edi,
 925          *flags);
 926 #endif
 927
 928   // save ret addr:
 929   ret_array[ret_i]=((uint32_t *)stack_base)[0];
 930   ++ret_i;
 931
 932 #if 0
 933   // print first 7 longs in the stack (return address, arg[1], arg[2] ... )
 934   printf("stack[] = { ");
 935   for (i=0;i<7;i++) {
 936     printf("%08x ", ((uint32_t *)stack_base)[i]);
 937   }
 938   printf("}\n\n");
 939 #endif
 940
 941 //  // mess with function parameters
 942 //  ((uint32_t *)stack_base)[1] = 0x66554433;
 943
 944 //  // mess with return address...
 945 //  reg->eax = 0x11223344;
 946     return 0;
 947 }
 948
 949 static int report_func_ret(void *stack_base, int stack_size, reg386_t *reg, uint32_t *flags)
 950 {
 951   //int i;
 952 #ifdef DEBUG_QTX_API
 953   short err;
 954 #endif
 955
 956   // restore ret addr:
 957   --ret_i;
 958   ((uint32_t *)stack_base)[0]=ret_array[ret_i];
 959
 960 #ifdef DEBUG_QTX_API
 961
 962 #if 1
 963   printf("%*sLEAVE(%d): 0x%X",ret_i*2,"",ret_i, reg->eax);
 964   err=reg->eax;
 965   if(err && (reg->eax>>16)==0) printf(" = %d",err);
 966   printf("\n");
 967   fflush(stdout);
 968 #else
 969   // print stack/reg information
 970   printf("LEAVE(%d) stack = %d bytes @ %p\n"
 971          "eax = 0x%08x edx = 0x%08x ebx = 0x%08x ecx = 0x%08x\n"
 972          "esp = 0x%08x ebp = 0x%08x esi = 0x%08x edi = 0x%08x\n"
 973          "flags = 0x%08x\n", ret_i,
 974          stack_size, stack_base,
 975          reg->eax, reg->edx, reg->ebx, reg->ecx,
 976          reg->esp, reg->ebp, reg->esi, reg->edi,
 977          *flags);
 978 #endif
 979
 980 #if 0
 981   // print first 7 longs in the stack (return address, arg[1], arg[2] ... )
 982   printf("stack[] = { ");
 983   for (i=0;i<7;i++) {
 984     printf("%08x ", ((uint32_t *)stack_base)[i]);
 985   }
 986   printf("}\n\n");
 987 #endif
 988
 989 #endif
 990
 991 //  // mess with function parameters
 992 //  ((uint32_t *)stack_base)[1] = 0x66554433;
 993
 994 //  // mess with return address...
 995 //  reg->eax = 0x11223344;
 996     return 0;
 997 }
 998
 999 #endif
1000
1001 /***********************************************************************
1002  *           MODULE_GetProcAddress              (internal)
1003  */
1004 FARPROC MODULE_GetProcAddress(
1005         HMODULE hModule,        /* [in] current module handle */
1006         LPCSTR function,        /* [in] function to be looked up */
1007         WIN_BOOL snoop )
1008 {
1009     WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
1010 //    WINE_MODREF *wm=local_wm;
1011     FARPROC     retproc;
1012
1013 #ifdef DEBUG_QTX_API
1014     if (HIWORD(function))
1015         fprintf(stderr,"XXX GetProcAddress(%08lx,%s)\n",(DWORD)hModule,function);
1016     else
1017         fprintf(stderr,"XXX GetProcAddress(%08lx,%p)\n",(DWORD)hModule,function);
1018 #endif
1019
1020 //      TRACE_(win32)("(%08lx,%s)\n",(DWORD)hModule,function);
1021 //    else
1022 //      TRACE_(win32)("(%08lx,%p)\n",(DWORD)hModule,function);
1023
1024     if (!wm) {
1025         SetLastError(ERROR_INVALID_HANDLE);
1026         return (FARPROC)0;
1027     }
1028     switch (wm->type)
1029     {
1030     case MODULE32_PE:
1031         retproc = PE_FindExportedFunction( wm, function, snoop );
1032         if (!retproc) SetLastError(ERROR_PROC_NOT_FOUND);
1033         break;
1034 #ifdef HAVE_LIBDL
1035     case MODULE32_ELF:
1036         retproc = (FARPROC) dlsym( (void*) wm->module, function);
1037         if (!retproc) SetLastError(ERROR_PROC_NOT_FOUND);
1038         return retproc;
1039 #endif
1040     default:
1041         ERR("wine_modref type %d not handled.\n",wm->type);
1042         SetLastError(ERROR_INVALID_HANDLE);
1043         return (FARPROC)0;
1044     }
1045
1046 #ifdef EMU_QTX_API
1047     if (HIWORD(function) && retproc){
1048
1049 #ifdef DEBUG_QTX_API
1050 #define DECL_COMPONENT(sname,name,type) \
1051     if(!strcmp(function,name)){ \
1052         fprintf(stderr,name "dispatcher catched -> %p\n",retproc); \
1053         real_ ## sname = retproc; retproc = fake_ ## sname; \
1054     }
1055 #include "qt_comp.h"
1056 #undef DECL_COMPONENT
1057 #endif
1058
1059     if(!strcmp(function,"theQuickTimeDispatcher")
1060 //      || !strcmp(function,"CallComponentFunctionWithStorage")
1061 //      || !strcmp(function,"CallComponent")
1062       ){
1063         fprintf(stderr,"theQuickTimeDispatcher catched -> %p\n",retproc);
1064       report_entry = report_func;
1065       report_ret   = report_func_ret;
1066       wrapper_target=(void(*)(void))retproc;
1067       retproc=(FARPROC)wrapper;
1068     }
1069
1070     }
1071 #endif
1072
1073     return retproc;
1074 }
1075
1076 static int acounter = 0;
1077 void CodecAlloc(void)
1078 {
1079     acounter++;
1080     //printf("**************CODEC ALLOC %d\n", acounter);
1081 }
1082
1083 void CodecRelease(void)
1084 {
1085     acounter--;
1086     //printf("**************CODEC RELEASE %d\n", acounter);
1087     if (acounter == 0)
1088     {
1089         for (;;)
1090         {
1091             modref_list* list = local_wm;
1092             if (!local_wm)
1093                 break;
1094             //printf("CODECRELEASE %p\n", list);
1095             MODULE_FreeLibrary(list->wm);
1096             MODULE_RemoveFromList(list->wm);
1097             if (local_wm == NULL)
1098                 my_garbagecollection();
1099         }
1100     }
1101 }