开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
module.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：32k
源码类别：

midi

开发平台：

Unix_Linux

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