diff options
| -rw-r--r-- | loader/Makefile | 2 | ||||
| -rw-r--r-- | loader/module.c | 408 | ||||
| -rw-r--r-- | loader/qt_comp.h | 27 | ||||
| -rw-r--r-- | loader/qt_fv.h | 1586 | ||||
| -rw-r--r-- | loader/wrapper.S | 83 | ||||
| -rw-r--r-- | loader/wrapper.h | 20 |
6 files changed, 2120 insertions, 6 deletions
diff --git a/loader/Makefile b/loader/Makefile index fe48cc08ce..6679f17e34 100644 --- a/loader/Makefile +++ b/loader/Makefile @@ -6,7 +6,7 @@ DEFINES=$(WIN32_PATH) -DMPLAYER -D__WINE__ -Ddbg_printf=__vprintf \ LIB_OBJECTS= ldt_keeper.o pe_image.o module.o \ ext.o win32.o driver.o pe_resource.o \ -resource.o registry.o elfdll.o afl.o vfl.o +resource.o registry.o elfdll.o afl.o vfl.o wrapper.o # gcc-3.0 produces buggy code for acmStreamOpen() with # "-O3 -fomit-frame-pointer" or "-O2 -fomit-frame-pointer diff --git a/loader/module.c b/loader/module.c index b532c06def..81a699d09c 100644 --- a/loader/module.c +++ b/loader/module.c @@ -3,6 +3,13 @@ * * Copyright 1995 Alexandre Julliard */ + +// define for quicktime calls debugging and/or MacOS-level emulation: +//#define EMU_QTX_API + +// define for quicktime debugging (verbose logging): +//#define DEBUG_QTX_API + #include "config.h" #include <assert.h> @@ -15,13 +22,15 @@ #include <sys/mman.h> #include <sys/types.h> - #include "wine/windef.h" #include "wine/winerror.h" #include "wine/heap.h" #include "wine/module.h" #include "wine/pe_image.h" #include "wine/debugtools.h" + +#undef HAVE_LIBDL + #ifdef HAVE_LIBDL #include <dlfcn.h> #include "wine/elfdll.h" @@ -29,6 +38,12 @@ #include "win32.h" #include "driver.h" +#ifdef EMU_QTX_API +#include "wrapper.h" +static int report_func(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags); +static int report_func_ret(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags); +#endif + //#undef TRACE //#define TRACE printf @@ -43,7 +58,8 @@ WINE_MODREF* MODULE_FindModule(LPCSTR m) TRACE("Module %s request\n", m); if(list==NULL) return NULL; - while(strcmp(m, list->wm->filename)) +// while(strcmp(m, list->wm->filename)) + while(!strstr(list->wm->filename, m)) { TRACE("%s: %x\n", list->wm->filename, list->wm->module); list=list->prev; @@ -295,6 +311,17 @@ static WINE_MODREF *MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD fl /* decrement the dependencies through the MODULE_FreeLibrary call. */ pwm->refCount++; +#ifdef EMU_QTX_API + if(strstr(libname,"QuickTime.qts")){ + void** ptr=0x62b75ca4; + fprintf(stderr,"QuickTime.qts entrypoint patched!!! old=%p\n",ptr[0]); + report_entry = report_func; + report_ret = report_func_ret; + wrapper_target=ptr[0]; + ptr[0]=wrapper; + } +#endif + SetLastError( err ); /* restore last error */ return pwm; } @@ -344,6 +371,10 @@ HMODULE WINAPI LoadLibraryExA(LPCSTR libname, HANDLE hfile, DWORD flags) SetLastError(ERROR_INVALID_PARAMETER); return 0; } + + wm=MODULE_FindModule(libname); + if(wm) return wm->module; + // if(fs_installed==0) // install_fs(); @@ -472,6 +503,337 @@ FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR function ) return MODULE_GetProcAddress( hModule, function, TRUE ); } +#ifdef DEBUG_QTX_API + +struct ComponentParameters { + unsigned char flags; /* call modifiers: sync/async, deferred, immed, etc */ + unsigned char paramSize; /* size in bytes of actual parameters passed to this call */ + short what; /* routine selector, negative for Component management calls */ + long params[1]; /* actual parameters for the indicated routine */ +}; +typedef struct ComponentParameters ComponentParameters; + +static char* component_func(int what){ +switch(what){ +case -1: return "kComponentOpenSelect"; +case -2: return "kComponentCloseSelect"; +case -3: return "kComponentCanDoSelect"; +case -4: return "kComponentVersionSelect"; +case -5: return "kComponentRegisterSelect"; +case -6: return "kComponentTargetSelect"; +case -7: return "kComponentUnregisterSelect"; +} +return "???"; +} + +static char* component_func_type(int type,int what){ +if(type==1) switch(what){ +case 0: return "kImageCodecGetCodecInfoSelect"; +case 1: return "kImageCodecGetCompressionTimeSelect"; +case 5: return "kImageCodecPreDecompressSelect"; +case 6: return "kImageCodecBandDecompressSelect"; +case 0x12: return "kImageCodecDisposeMemorySelect"; +case 0x10: return "kImageCodecIsImageDescriptionEquivalentSelect"; +case 0x14: return "kImageCodecNewImageBufferMemorySelect"; +case 0x28: return "kImageCodecRequestGammaLevelSelect"; +} +return "???"; +} + + +static int c_level=0; + +static int dump_component(char* name,int type,void* _orig, ComponentParameters *params,void** glob){ + int ( *orig)(ComponentParameters *params, void** glob) = _orig; + int ret,i; + + if(params->what<0) + fprintf(stderr,"%*sComponentCall: %s flags=0x%X size=%d what=%d %s\n",3*c_level,"",name,params->flags, params->paramSize, params->what, component_func(params->what)); + else + 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_type(type,params->what)); + + for(i=0;i<params->paramSize/4;i++) + fprintf(stderr,"%*s param[%d] = 0x%X\n",3*c_level,"",i,params->params[i]); + + ++c_level; + ret=orig(params,glob); + --c_level; + + if(ret>=0x1000) + fprintf(stderr,"%*s return=0x%X\n",3*c_level,"",ret); + else + fprintf(stderr,"%*s return=%d\n",3*c_level,"",ret); + return ret; +} + +#define DECL_COMPONENT(sname,name,type) \ + static void* real_ ## sname = NULL; \ + static int fake_ ## sname(ComponentParameters *params,void** glob){ \ + return dump_component(name,type,real_ ## sname, params, glob); \ + } + +#include "qt_comp.h" + +#undef DECL_COMPONENT + +#include "qt_fv.h" + +#endif + +#ifdef EMU_QTX_API + +static u_int32_t ret_array[4096]; +static int ret_i=0; + +static int report_func(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags) +{ +#ifdef DEBUG_QTX_API + int i; + int* dptr; + void* pwrapper=NULL; + void* pptr=NULL; + char* pname=NULL; + int plen=-1; + // find the code: + + dptr=0x62b67ae0;dptr+=2*((reg->eax>>16)&255); +// printf("FUNC: flag=%d ptr=%p\n",dptr[0],dptr[1]); + if(dptr[0]&255){ + dptr=dptr[1];dptr+=4*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",dptr[1],dptr[0],dptr[2]); + pwrapper=dptr[1]; pptr=dptr[0]; plen=dptr[2]; + } else { + pwrapper=0x62924910; + switch(dptr[1]){ + case 0x629248d0: + dptr=0x62b672c0;dptr+=2*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",0x62924910,dptr[0],dptr[1]); + pptr=dptr[0]; plen=dptr[1]; + break; + case 0x62924e40: + dptr=0x62b67c70;dptr+=2*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",0x62924910,dptr[0],dptr[1]); + pptr=dptr[0]; plen=dptr[1]; + break; + case 0x62924e60: + dptr=0x62b68108;if(reg->eax&0x8000) dptr+=2*(reg->eax|0xffff0000); else dptr+=2*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",0x62924910,dptr[0],dptr[1]); + pptr=dptr[0]; plen=dptr[1]; + break; + case 0x62924e80: + dptr=0x62b68108;if(reg->eax&0x8000) dptr+=2*(reg->eax|0xffff0000); else dptr+=2*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",0x62924910,dptr[0],dptr[1]); + pptr=dptr[0]; plen=dptr[1]; + break; + default: + printf("FUNC: unknown ptr & psize!\n"); + pwrapper=dptr[1]; + } + } + + for(i=0;qt_fv_list[i].name;i++){ + if(qt_fv_list[i].id==reg->eax){ + pname=qt_fv_list[i].name; + break; + } + } + + printf("FUNC[%X/%s]: wrapper=%p func=%p len=%d\n",reg->eax, + pname?pname:"???",pwrapper,pptr,plen); + + printf("FUNC: caller=%p ebx=%p\n",((u_int32_t *)stack_base)[0],reg->ebx); + + if(pname) + printf("%*sENTER(%d): %s(",ret_i*2,"",ret_i,pname); + else + printf("%*sENTER(%d): %X(",ret_i*2,"",ret_i,reg->eax); + for (i=0;i<plen/4;i++){ + unsigned int val=((u_int32_t *)stack_base)[1+i]; + unsigned char* fcc=&val; + printf("%s0x%X", i?", ":"",val); + if(fcc[0]>=0x20 && fcc[0]<128 && + fcc[1]>=0x20 && fcc[1]<128 && + fcc[2]>=0x20 && fcc[2]<128 && + fcc[3]>=0x20 && fcc[3]<128) printf("='%c%c%c%c'",fcc[3],fcc[2],fcc[1],fcc[0]); + else if(val>=8 && val<65536) printf("=%d",val); + } + printf(")\n"); + fflush(stdout); + +#endif + +#if 1 + // emulate some functions: + switch(reg->eax){ + // memory management: + case 0x150011: //NewPtrClear + case 0x150012: //NewPtrSysClear + reg->eax=malloc(((u_int32_t *)stack_base)[1]); + memset(reg->eax,0,((u_int32_t *)stack_base)[1]); +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + case 0x15000F: //NewPtr + case 0x150010: //NewPtrSys + reg->eax=malloc(((u_int32_t *)stack_base)[1]); +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + case 0x15002f: //DisposePtr + if(((u_int32_t *)stack_base)[1]>=0x60000000) + printf("WARNING! Invalid Ptr handle!\n"); + else + free(((u_int32_t *)stack_base)[1]); + reg->eax=0; +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + // mutexes: + case 0x1d0033: //QTMLCreateMutex + reg->eax=0xdeadbabe; +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + case 0x1d0034: //QTMLDestroyMutex + case 0x1d0035: //QTMLGrabMutex + case 0x1d0036: //QTMLReturnMutex + case 0x1d003d: //QTMLTryGrabMutex + reg->eax=0; +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + } +#endif + +#if 0 + switch(reg->eax){ +// case 0x00010000: +// printf("FUNC: ImageCodecInitialize/ImageCodecGetCodecInfo(ci=%p,&icap=%p)\n",((u_int32_t *)stack_base)[1],((u_int32_t *)stack_base)[4]); +// break; + case 0x00010003: + printf("FUNC: CountComponents(&desc=%p)\n",((u_int32_t *)stack_base)[1]); + break; + case 0x00010004: + printf("FUNC: FindNextComponent(prev=%p,&desc=%p)\n",((u_int32_t *)stack_base)[1],((u_int32_t *)stack_base)[2]); + break; + case 0x00010007: + printf("FUNC: OpenComponent(prev=%p)\n",((u_int32_t *)stack_base)[1]); + break; + case 0x0003008b: + printf("FUNC: QTNewGWorldFromPtr(&pts=%p,fourcc=%.4s,&rect=%p,x1=%p,x2=%p,x3=%p,plane=%p,stride=%d)\n", + ((u_int32_t *)stack_base)[1], + &(((u_int32_t *)stack_base)[2]), + ((u_int32_t *)stack_base)[3], + ((u_int32_t *)stack_base)[4], + ((u_int32_t *)stack_base)[5], + ((u_int32_t *)stack_base)[6], + ((u_int32_t *)stack_base)[7], + ((u_int32_t *)stack_base)[8]); + break; + case 0x001c0018: + printf("FUNC: GetGWorldPixMap(gworld=%p)\n",((u_int32_t *)stack_base)[1]); + break; + case 0x00110001: + printf("FUNC: Gestalt(fourcc=%.4s, &ret=%p)\n",&(((u_int32_t *)stack_base)[1]),((u_int32_t *)stack_base)[2]); + break; + default: { + int i; + for(i=0;qt_fv_list[i].name;i++){ + if(qt_fv_list[i].id==reg->eax){ + printf("FUNC: %s\n",qt_fv_list[i].name); + break; + } + } + } + } + + // print stack/reg information + printf("ENTER(%d) stack = %d bytes @ %p\n" + "eax = 0x%08x edx = 0x%08x ebx = 0x%08x ecx = 0x%08x\n" + "esp = 0x%08x ebp = 0x%08x esi = 0x%08x edi = 0x%08x\n" + "flags = 0x%08x\n", ret_i, + stack_size, stack_base, + reg->eax, reg->edx, reg->ebx, reg->ecx, + reg->esp, reg->ebp, reg->esi, reg->edi, + *flags); +#endif + + // save ret addr: + ret_array[ret_i]=((u_int32_t *)stack_base)[0]; + ++ret_i; + +#if 0 + // print first 7 longs in the stack (return address, arg[1], arg[2] ... ) + printf("stack[] = { "); + for (i=0;i<7;i++) { + printf("%08x ", ((u_int32_t *)stack_base)[i]); + } + printf("}\n\n"); +#endif + +// // mess with function parameters +// ((u_int32_t *)stack_base)[1] = 0x66554433; + +// // mess with return address... +// reg->eax = 0x11223344; + return 0; +} + +static int report_func_ret(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags) +{ + int i; + short err; + + // restore ret addr: + --ret_i; + ((u_int32_t *)stack_base)[0]=ret_array[ret_i]; + +#ifdef DEBUG_QTX_API + +#if 1 + printf("%*sLEAVE(%d): 0x%X",ret_i*2,"",ret_i, reg->eax); + err=reg->eax; + if(err && (reg->eax>>16)==0) printf(" = %d",err); + printf("\n"); + fflush(stdout); +#else + // print stack/reg information + printf("LEAVE(%d) stack = %d bytes @ %p\n" + "eax = 0x%08x edx = 0x%08x ebx = 0x%08x ecx = 0x%08x\n" + "esp = 0x%08x ebp = 0x%08x esi = 0x%08x edi = 0x%08x\n" + "flags = 0x%08x\n", ret_i, + stack_size, stack_base, + reg->eax, reg->edx, reg->ebx, reg->ecx, + reg->esp, reg->ebp, reg->esi, reg->edi, + *flags); +#endif + +#if 0 + // print first 7 longs in the stack (return address, arg[1], arg[2] ... ) + printf("stack[] = { "); + for (i=0;i<7;i++) { + printf("%08x ", ((u_int32_t *)stack_base)[i]); + } + printf("}\n\n"); +#endif + +#endif + +// // mess with function parameters +// ((u_int32_t *)stack_base)[1] = 0x66554433; + +// // mess with return address... +// reg->eax = 0x11223344; + return 0; +} + +#endif + /*********************************************************************** * MODULE_GetProcAddress (internal) */ @@ -484,10 +846,17 @@ FARPROC MODULE_GetProcAddress( // WINE_MODREF *wm=local_wm; FARPROC retproc; +#ifdef DEBUG_QTX_API if (HIWORD(function)) - TRACE_(win32)("(%08lx,%s)\n",(DWORD)hModule,function); + fprintf(stderr,"XXX GetProcAddress(%08lx,%s)\n",(DWORD)hModule,function); else - TRACE_(win32)("(%08lx,%p)\n",(DWORD)hModule,function); + fprintf(stderr,"XXX GetProcAddress(%08lx,%p)\n",(DWORD)hModule,function); +#endif + +// TRACE_(win32)("(%08lx,%s)\n",(DWORD)hModule,function); +// else +// TRACE_(win32)("(%08lx,%p)\n",(DWORD)hModule,function); + if (!wm) { SetLastError(ERROR_INVALID_HANDLE); return (FARPROC)0; @@ -497,7 +866,7 @@ FARPROC MODULE_GetProcAddress( case MODULE32_PE: retproc = PE_FindExportedFunction( wm, function, snoop ); if (!retproc) SetLastError(ERROR_PROC_NOT_FOUND); - return retproc; + break; #ifdef HAVE_LIBDL case MODULE32_ELF: retproc = (FARPROC) dlsym( (void*) wm->module, function); @@ -509,6 +878,35 @@ FARPROC MODULE_GetProcAddress( SetLastError(ERROR_INVALID_HANDLE); return (FARPROC)0; } + +#ifdef EMU_QTX_API + if (HIWORD(function) && retproc){ + +#ifdef DEBUG_QTX_API +#define DECL_COMPONENT(sname,name,type) \ + if(!strcmp(function,name)){ \ + fprintf(stderr,name "dispatcher catched -> %p\n",retproc); \ + real_ ## sname = retproc; retproc = fake_ ## sname; \ + } +#include "qt_comp.h" +#undef DECL_COMPONENT +#endif + + if(!strcmp(function,"theQuickTimeDispatcher") +// || !strcmp(function,"_CallComponentFunctionWithStorage") +// || !strcmp(function,"_CallComponent") + ){ + fprintf(stderr,"theQuickTimeDispatcher catched -> %p\n",retproc); + report_entry = report_func; + report_ret = report_func_ret; + wrapper_target=retproc; + retproc=wrapper; + } + + } +#endif + + return retproc; } static int acounter = 0; diff --git a/loader/qt_comp.h b/loader/qt_comp.h new file mode 100644 index 0000000000..7ceeb5dbbb --- /dev/null +++ b/loader/qt_comp.h @@ -0,0 +1,27 @@ + +DECL_COMPONENT(sorenson3,"SMD_ComponentDispatch",1) +DECL_COMPONENT(sorenson,"SorensonYUV9Dispatcher",1) +DECL_COMPONENT(sorenson1,"SVD_ComponentDispatch",1) +DECL_COMPONENT(genericd,"GenericComponentDispatch",0) +DECL_COMPONENT(stmedia,"STMediaComponentDispatch",0) +DECL_COMPONENT(handlecd,"HandleComponentDispatch",0) +DECL_COMPONENT(pcxcd,"PCExchangeComponentDispatch",0) +DECL_COMPONENT(capcd,"CapComponentDispatch",0) +DECL_COMPONENT(videocd,"VideoComponentDispatch",0) +DECL_COMPONENT(soundcd,"SoundComponentDispatch",0) +DECL_COMPONENT(scalingcd,"ScalingCodecDispatcher",0) +DECL_COMPONENT(formatcnv,"FormatConverterDispatch",0) + +DECL_COMPONENT(basecd,"Base_CDComponentDispatch",1) +DECL_COMPONENT(ddcd,"DD_CDComponentDispatch",0) +DECL_COMPONENT(fakergb,"FakeRGBDispatcher",0) +DECL_COMPONENT(rawcd,"RAW_CDComponentDispatch",0) +DECL_COMPONENT(yuvsgi,"YUVSGI_CDComponentDispatch",0) +DECL_COMPONENT(yuvs,"YUVS_CDComponentDispatch",0) +DECL_COMPONENT(yuvu,"YUVU_CDComponentDispatch",0) + +DECL_COMPONENT(qdm2d,"QDM2Decompressor",0) +DECL_COMPONENT(mace3d,"Mace3DecompDispatch",0) + +//DECL_COMPONENT(,"",0) + diff --git a/loader/qt_fv.h b/loader/qt_fv.h new file mode 100644 index 0000000000..6531e4a1c1 --- /dev/null +++ b/loader/qt_fv.h @@ -0,0 +1,1586 @@ +typedef struct qt_fv_s { + unsigned int id; + char* name; +} qt_fv_t; + +qt_fv_t qt_fv_list[]={ +{ 0x20001, "EnterMovies"}, +{ 0x20002, "ExitMovies"}, +{ 0x20003, "GetMoviesError"}, +{ 0x20004, "GetMoviesStickyError"}, +{ 0x20005, "MoviesTask"}, +{ 0x20006, "PrerollMovie"}, +{ 0x20007, "LoadMovieIntoRam"}, +{ 0x20008, "LoadMediaIntoRam"}, +{ 0x20009, "SetMovieActive"}, +{ 0x2000a, "GetMovieActive"}, +{ 0x2000b, "StartMovie"}, +{ 0x2000c, "StopMovie"}, +{ 0x2000d, "GoToBeginningOfMovie"}, +{ 0x2000e, "GoToEndOfMovie"}, +{ 0x2000f, "GetMoviePreviewMode"}, +{ 0x20010, "SetMoviePreviewMode"}, +{ 0x20011, "ShowMoviePoster"}, +{ 0x20012, "GetMovieTimeBase"}, +{ 0x20015, "GetMovieGWorld"}, +{ 0x20016, "SetMovieGWorld"}, +{ 0x2001d, "GetMoviePict"}, +{ 0x2001e, "GetTrackPict"}, +{ 0x2001f, "UpdateMovie"}, +{ 0x20022, "PutMovieIntoHandle"}, +{ 0x20023, "DisposeMovie"}, +{ 0x20026, "GetMovieCreationTime"}, +{ 0x20027, "GetMovieModificationTime"}, +{ 0x20029, "GetMovieTimeScale"}, +{ 0x2002a, "SetMovieTimeScale"}, +{ 0x2002b, "GetMovieDuration"}, +{ 0x2002c, "GetMovieRate"}, +{ 0x2002d, "SetMovieRate"}, +{ 0x2002e, "GetMovieVolume"}, +{ 0x2002f, "SetMovieVolume"}, +{ 0x20031, "GetMovieMatrix"}, +{ 0x20032, "SetMovieMatrix"}, +{ 0x20033, "GetMoviePreviewTime"}, +{ 0x20034, "SetMoviePreviewTime"}, +{ 0x20035, "GetMoviePosterTime"}, +{ 0x20036, "SetMoviePosterTime"}, +{ 0x20037, "GetMovieSelection"}, +{ 0x20038, "SetMovieSelection"}, +{ 0x20039, "GetMovieTime"}, +{ 0x2003c, "SetMovieTime"}, +{ 0x2003d, "SetMovieTimeValue"}, +{ 0x2003e, "GetMovieUserData"}, +{ 0x2003f, "GetMovieTrackCount"}, +{ 0x20040, "GetMovieTrack"}, +{ 0x20042, "DisposeMovieTrack"}, +{ 0x20043, "GetTrackCreationTime"}, +{ 0x20044, "GetTrackModificationTime"}, +{ 0x20045, "GetTrackEnabled"}, +{ 0x20046, "SetTrackEnabled"}, +{ 0x20047, "GetTrackUsage"}, +{ 0x20048, "SetTrackUsage"}, +{ 0x2004b, "GetTrackDuration"}, +{ 0x2004c, "GetTrackOffset"}, +{ 0x2004d, "SetTrackOffset"}, +{ 0x20050, "GetTrackLayer"}, +{ 0x20051, "SetTrackLayer"}, +{ 0x20052, "GetTrackAlternate"}, +{ 0x20053, "SetTrackAlternate"}, +{ 0x20054, "GetTrackVolume"}, +{ 0x20055, "SetTrackVolume"}, +{ 0x20056, "GetTrackMatrix"}, +{ 0x20057, "SetTrackMatrix"}, +{ 0x2005d, "GetTrackDimensions"}, +{ 0x2005e, "SetTrackDimensions"}, +{ 0x2005f, "GetTrackUserData"}, +{ 0x20061, "DisposeTrackMedia"}, +{ 0x20062, "GetTrackMedia"}, +{ 0x20066, "GetMediaCreationTime"}, +{ 0x20067, "GetMediaModificationTime"}, +{ 0x20068, "GetMediaTimeScale"}, +{ 0x20069, "SetMediaTimeScale"}, +{ 0x2006a, "GetMediaDuration"}, +{ 0x2006b, "GetMediaLanguage"}, +{ 0x2006c, "SetMediaLanguage"}, +{ 0x2006d, "GetMediaQuality"}, +{ 0x2006e, "SetMediaQuality"}, +{ 0x2006f, "GetMediaHandlerDescription"}, +{ 0x20070, "GetMediaUserData"}, +{ 0x20071, "GetMediaHandler"}, +{ 0x20072, "BeginMediaEdits"}, +{ 0x20073, "EndMediaEdits"}, +{ 0x20074, "AddEmptyTrackToMovie"}, +{ 0x20077, "GetMediaSampleDescriptionCount"}, +{ 0x20078, "GetMediaSampleDescription"}, +{ 0x20079, "GetMediaSampleCount"}, +{ 0x2007a, "SampleNumToMediaTime"}, +{ 0x2007b, "MediaTimeToSampleNum"}, +{ 0x2007c, "AddMediaSample"}, +{ 0x2007d, "AddMediaSampleReference"}, +{ 0x2007e, "GetMediaSample"}, +{ 0x2007f, "GetMediaSampleReference"}, +{ 0x20084, "CloneRgn"}, +{ 0x20085, "InsertTrackSegment"}, +{ 0x20086, "InsertMovieSegment"}, +{ 0x20087, "InsertEmptyTrackSegment"}, +{ 0x20088, "InsertEmptyMovieSegment"}, +{ 0x20089, "DeleteTrackSegment"}, +{ 0x2008a, "DeleteMovieSegment"}, +{ 0x2008b, "ScaleTrackSegment"}, +{ 0x2008c, "ScaleMovieSegment"}, +{ 0x2008d, "CutMovieSelection"}, +{ 0x2008e, "CopyMovieSelection"}, +{ 0x2008f, "PasteMovieSelection"}, +{ 0x20096, "TrackTimeToMediaTime"}, +{ 0x20098, "GetMovieDataSize"}, +{ 0x20099, "GetMediaDataSize"}, +{ 0x2009a, "PtInMovie"}, +{ 0x2009b, "PtInTrack"}, +{ 0x2009c, "SetMovieLanguage"}, +{ 0x2009d, "SetTrackGWorld"}, +{ 0x2009e, "GetUserData"}, +{ 0x2009f, "AddUserData"}, +{ 0x200a0, "RemoveUserData"}, +{ 0x200a5, "NewTimeBase"}, +{ 0x200a6, "GetTimeBaseTime"}, +{ 0x200a7, "SetTimeBaseTime"}, +{ 0x200a8, "SetTimeBaseValue"}, +{ 0x200a9, "GetTimeBaseRate"}, +{ 0x200aa, "SetTimeBaseRate"}, +{ 0x200ab, "GetTimeBaseStartTime"}, +{ 0x200ac, "SetTimeBaseStartTime"}, +{ 0x200ad, "GetTimeBaseStopTime"}, +{ 0x200ae, "SetTimeBaseStopTime"}, +{ 0x200af, "GetTimeBaseMasterTimeBase"}, +{ 0x200b0, "GetTimeBaseMasterClock"}, +{ 0x200b1, "GetTimeBaseFlags"}, +{ 0x200b2, "SetTimeBaseFlags"}, +{ 0x200b3, "SetTimeBaseMasterClock"}, +{ 0x200b4, "SetTimeBaseMasterTimeBase"}, +{ 0x200b5, "ConvertTime"}, +{ 0x200b6, "DisposeTimeBase"}, +{ 0x200b7, "ConvertTimeScale"}, +{ 0x200b8, "CallMeWhen"}, +{ 0x200b9, "CancelCallBack"}, +{ 0x200c5, "GetMediaTrack"}, +{ 0x200cb, "PasteHandleIntoMovie"}, +{ 0x200cc, "IsScrapMovie"}, +{ 0x200d0, "GetTrackMovie"}, +{ 0x200d5, "CloseMovieFile"}, +{ 0x200d7, "AddMovieResource"}, +{ 0x200d8, "UpdateMovieResource"}, +{ 0x200d9, "HasMovieChanged"}, +{ 0x200dd, "IsMovieDone"}, +{ 0x200de, "ClearMoviesStickyError"}, +{ 0x200e1, "ClearMovieSelection"}, +{ 0x200e2, "GetTrackNextInterestingTime"}, +{ 0x200eb, "NewCallBack"}, +{ 0x200ec, "DisposeCallBack"}, +{ 0x200ed, "GetCallBackType"}, +{ 0x200ee, "GetCallBackTimeBase"}, +{ 0x200ef, "SetMoviesErrorProc"}, +{ 0x200f0, "NewMovieFromFile"}, +{ 0x200f1, "NewMovieFromHandle"}, +{ 0x200f2, "PlayMoviePreview"}, +{ 0x200f3, "GetMoviePreferredRate"}, +{ 0x200f4, "SetMoviePreferredRate"}, +{ 0x200f5, "GetMoviePreferredVolume"}, +{ 0x200f6, "SetMoviePreferredVolume"}, +{ 0x200f7, "GetMoviePosterPict"}, +{ 0x200f9, "GetMovieBox"}, +{ 0x200fa, "SetMovieBox"}, +{ 0x200fb, "GetMovieDisplayBoundsRgn"}, +{ 0x200fc, "GetMovieDisplayClipRgn"}, +{ 0x200fd, "SetMovieDisplayClipRgn"}, +{ 0x200fe, "GetMovieBoundsRgn"}, +{ 0x200ff, "GetTrackMovieBoundsRgn"}, +{ 0x20100, "GetMovieClipRgn"}, +{ 0x20101, "SetMovieClipRgn"}, +{ 0x20102, "GetTrackClipRgn"}, +{ 0x20103, "SetTrackClipRgn"}, +{ 0x20104, "NewMovieEditState"}, +{ 0x20105, "UseMovieEditState"}, +{ 0x20106, "DisposeMovieEditState"}, +{ 0x20107, "NewTrackEditState"}, +{ 0x20108, "UseTrackEditState"}, +{ 0x20109, "DisposeTrackEditState"}, +{ 0x2010b, "GetTimeBaseStatus"}, +{ 0x2010c, "AddTime"}, +{ 0x2010d, "SubtractTime"}, +{ 0x2010e, "GetMovieNextInterestingTime"}, +{ 0x20111, "GetTrackBoundsRgn"}, +{ 0x20112, "GetTrackDisplayBoundsRgn"}, +{ 0x20113, "ClearMovieChanged"}, +{ 0x20115, "GetTrackMatte"}, +{ 0x20116, "SetTrackMatte"}, +{ 0x20117, "GetMovieIndTrack"}, +{ 0x20121, "SetMediaShadowSync"}, +{ 0x20122, "GetMediaShadowSync"}, +{ 0x20123, "GetTrackEditRate"}, +{ 0x20124, "GetTimeBaseEffectiveRate"}, +{ 0x20126, "GetUserDataItem"}, +{ 0x20127, "GetTrackID"}, +{ 0x20128, "SetTimeBaseZero"}, +{ 0x20129, "AddCallBackToTimeBase"}, +{ 0x2012a, "RemoveCallBackFromTimeBase"}, +{ 0x2012b, "GetFirstCallBack"}, +{ 0x2012c, "GetNextCallBack"}, +{ 0x2012d, "ExecuteCallBack"}, +{ 0x2012e, "SetUserDataItem"}, +{ 0x2012f, "NewUserData"}, +{ 0x20130, "DisposeUserData"}, +{ 0x20131, "NewUserDataFromHandle"}, +{ 0x20132, "PutUserDataIntoHandle"}, +{ 0x20149, "GetTrackDataSize"}, +{ 0x2014a, "DisposeMatte"}, +{ 0x2014b, "CountUserDataType"}, +{ 0x2014c, "AddUserDataText"}, +{ 0x2014d, "GetUserDataText"}, +{ 0x2014e, "RemoveUserDataText"}, +{ 0x20152, "AddMovieSelection"}, +{ 0x20153, "CopyTrackSettings"}, +{ 0x20154, "CopyMovieSettings"}, +{ 0x2015c, "SetMovieActiveSegment"}, +{ 0x2015d, "GetMovieActiveSegment"}, +{ 0x2015e, "SetAutoTrackAlternatesEnabled"}, +{ 0x2015f, "SelectMovieAlternates"}, +{ 0x20167, "SetMovieMasterTimeBase"}, +{ 0x20168, "SetMovieMasterClock"}, +{ 0x2016b, "GetTrackSegmentDisplayBoundsRgn"}, +{ 0x2016c, "GetMovieSegmentDisplayBoundsRgn"}, +{ 0x2016d, "GetMediaNextInterestingTime"}, +{ 0x2016e, "LoadTrackIntoRam"}, +{ 0x2016f, "GetPosterBox"}, +{ 0x20170, "SetPosterBox"}, +{ 0x20172, "GetTrackStatus"}, +{ 0x20173, "GetMovieStatus"}, +{ 0x20175, "DeleteMovieFile"}, +{ 0x20176, "RemoveMovieResource"}, +{ 0x20179, "SetMovieCoverProcs"}, +{ 0x20183, "InsertMediaIntoTrack"}, +{ 0x20187, "NewMovie"}, +{ 0x20188, "NewMovieTrack"}, +{ 0x2018a, "NewMovieController"}, +{ 0x2018b, "DisposeMovieController"}, +{ 0x2018c, "PutMovieOnScrap"}, +{ 0x2018d, "NewMovieFromScrap"}, +{ 0x2018e, "NewTrackMedia"}, +{ 0x20190, "SetMediaHandler"}, +{ 0x20191, "CreateMovieFile"}, +{ 0x20192, "OpenMovieFile"}, +{ 0x20197, "GetMediaDataRef"}, +{ 0x20198, "AddMediaDataRef"}, +{ 0x20199, "GetMediaDataRefCount"}, +{ 0x2019a, "SetMovieProgressProc"}, +{ 0x2019b, "FlattenMovie"}, +{ 0x2019c, "FlattenMovieData"}, +{ 0x2019e, "GetMediaDataHandlerDescription"}, +{ 0x2019f, "GetMediaDataHandler"}, +{ 0x201a0, "SetMediaDataHandler"}, +{ 0x201a1, "SetMoviePlayHints"}, +{ 0x201a2, "SetMediaPlayHints"}, +{ 0x201a5, "GetNextUserDataType"}, +{ 0x201b3, "NewMovieFromDataFork"}, +{ 0x201b4, "PutMovieIntoDataFork"}, +{ 0x201c1, "SetMovieDefaultDataRef"}, +{ 0x201c9, "SetMediaDataRef"}, +{ 0x201ca, "SetMediaDataRefAttributes"}, +{ 0x201cb, "ConvertFileToMovieFile"}, +{ 0x201cc, "ConvertMovieToFile"}, +{ 0x201cd, "PutMovieIntoTypedHandle"}, +{ 0x201d0, "SetMediaSampleDescription"}, +{ 0x201d2, "GetMovieDefaultDataRef"}, +{ 0x201dd, "GetMovieCoverProcs"}, +{ 0x201de, "SetMovieDrawingCompleteProc"}, +{ 0x201e0, "SetMediaDefaultDataRefIndex"}, +{ 0x201e3, "SetTrackLoadSettings"}, +{ 0x201e4, "GetTrackLoadSettings"}, +{ 0x201ec, "NewMovieFromUserProc"}, +{ 0x201ed, "GetDataHandler"}, +{ 0x201f0, "AddTrackReference"}, +{ 0x201f1, "DeleteTrackReference"}, +{ 0x201f2, "SetTrackReference"}, +{ 0x201f3, "GetTrackReference"}, +{ 0x201f4, "GetNextTrackReferenceType"}, +{ 0x201f5, "GetTrackReferenceCount"}, +{ 0x201f7, "AddMediaSampleReferences"}, +{ 0x201f8, "SetMediaPreferredChunkSize"}, +{ 0x201f9, "GetMediaPreferredChunkSize"}, +{ 0x201fa, "GetNextTrackForCompositing"}, +{ 0x201fb, "GetPrevTrackForCompositing"}, +{ 0x201ff, "QTSwapAtoms"}, +{ 0x20200, "QTNextChildAnyType"}, +{ 0x20201, "QTNewAlias"}, +{ 0x20205, "SetMovieColorTable"}, +{ 0x20206, "GetMovieColorTable"}, +{ 0x20207, "MovieSearchText"}, +{ 0x20208, "GetMovieIndTrackType"}, +{ 0x20209, "ShowMovieInformation"}, +{ 0x2020c, "QTNewAtomContainer"}, +{ 0x2020d, "QTDisposeAtomContainer"}, +{ 0x2020e, "QTGetNextChildType"}, +{ 0x2020f, "QTCountChildrenOfType"}, +{ 0x20210, "QTFindChildByIndex"}, +{ 0x20211, "QTSetAtomData"}, +{ 0x20212, "QTCopyAtomDataToHandle"}, +{ 0x20213, "QTCopyAtomDataToPtr"}, +{ 0x20214, "QTCopyAtom"}, +{ 0x20215, "QTLockContainer"}, +{ 0x20216, "QTGetAtomDataPtr"}, +{ 0x20217, "QTUnlockContainer"}, +{ 0x20218, "QTInsertChild"}, +{ 0x20219, "QTInsertChildren"}, +{ 0x2021a, "QTRemoveAtom"}, +{ 0x2021b, "QTRemoveChildren"}, +{ 0x2021c, "QTReplaceAtom"}, +{ 0x2021d, "QTFindChildByID"}, +{ 0x20220, "NewMovieFromDataRef"}, +{ 0x2022a, "InvalidateMovieRegion"}, +{ 0x2022b, "TaskMovie"}, +{ 0x2022c, "GetMovieNaturalBoundsRect"}, +{ 0x2022e, "SetMediaPropertyAtom"}, +{ 0x2022f, "GetMediaPropertyAtom"}, +{ 0x20231, "QTSetAtomID"}, +{ 0x20232, "QTGetAtomTypeAndID"}, +{ 0x20233, "BeginFullScreen"}, +{ 0x20234, "EndFullScreen"}, +{ 0x20235, "GetMediaSampleReferences"}, +{ 0x20239, "NewSpriteWorld"}, +{ 0x2023a, "DisposeSpriteWorld"}, +{ 0x2023b, "SetSpriteWorldClip"}, +{ 0x2023c, "SetSpriteWorldMatrix"}, +{ 0x2023d, "SpriteWorldIdle"}, +{ 0x2023e, "InvalidateSpriteWorld"}, +{ 0x2023f, "DisposeAllSprites"}, +{ 0x20240, "NewSprite"}, +{ 0x20241, "DisposeSprite"}, +{ 0x20242, "InvalidateSprite"}, +{ 0x20243, "SetSpriteProperty"}, +{ 0x20244, "GetSpriteProperty"}, +{ 0x20246, "SpriteWorldHitTest"}, +{ 0x20247, "SpriteHitTest"}, +{ 0x20249, "GetMediaInputMap"}, +{ 0x2024a, "SetMediaInputMap"}, +{ 0x20263, "GetTrackDisplayMatrix"}, +{ 0x2027a, "ITextAddString"}, +{ 0x2027b, "ITextRemoveString"}, +{ 0x2027c, "ITextGetString"}, +{ 0x20282, "GetTrackSoundLocalizationSettings"}, +{ 0x20283, "SetTrackSoundLocalizationSettings"}, +{ 0x20284, "SetMoviePropertyAtom"}, +{ 0x20285, "GetMoviePropertyAtom"}, +{ 0x2029d, "QTNewTween"}, +{ 0x2029e, "QTDoTween"}, +{ 0x2029f, "QTDisposeTween"}, +{ 0x202b2, "GetMediaSyncSampleCount"}, +{ 0x202b3, "QTGetAccessKeys"}, +{ 0x202b4, "QTRegisterAccessKey"}, +{ 0x202b5, "QTUnregisterAccessKey"}, +{ 0x202be, "MakeTrackTimeTable"}, +{ 0x202bf, "MakeMediaTimeTable"}, +{ 0x202c0, "GetMaxLoadedTimeInMovie"}, +{ 0x202c2, "SetSpriteWorldFlags"}, +{ 0x202c3, "QTMovieNeedsTimeTable"}, +{ 0x202c6, "QTGetDataRefMaxFileOffset"}, +{ 0x202c7, "GetMovieImporterForDataRef"}, +{ 0x202c9, "QTGetEffectsList"}, +{ 0x202ca, "QTCreateStandardParameterDialog"}, +{ 0x202cb, "QTIsStandardParameterDialogEvent"}, +{ 0x202cc, "QTDismissStandardParameterDialog"}, +{ 0x202cd, "QTStandardParameterDialogDoAction"}, +{ 0x202ce, "GetMediaPlayHints"}, +{ 0x202cf, "AddSoundDescriptionExtension"}, +{ 0x202d0, "GetSoundDescriptionExtension"}, +{ 0x202d1, "RemoveSoundDescriptionExtension"}, +{ 0x202d2, "QTGetEffectSpeed"}, +{ 0x202d3, "QuickTimeExtensionLoaded"}, +{ 0x202d4, "GetQuickTimePreference"}, +{ 0x202d5, "SetQuickTimePreference"}, +{ 0x202d9, "SetSpriteWorldGraphicsMode"}, +{ 0x202da, "CheckQuickTimeRegistration"}, +{ 0x202db, "QTTextToNativeText"}, +{ 0x202e8, "AddMediaSampleReferences64"}, +{ 0x202e9, "GetMediaSampleReferences64"}, +{ 0x202ea, "PutMovieIntoDataFork64"}, +{ 0x202eb, "GetMovieDataSize64"}, +{ 0x202ec, "GetTrackDataSize64"}, +{ 0x202ed, "GetMediaDataSize64"}, +{ 0x202ee, "NewMovieFromDataFork64"}, +{ 0x202ef, "QTGetAtomParent"}, +{ 0x202f1, "QTReportMissingSoftware"}, +{ 0x202f4, "InstallQuickTimeExtensionRequest"}, +{ 0x202f5, "QTBandwidthRequest"}, +{ 0x202f6, "QTBandwidthRelease"}, +{ 0x202f7, "PrePrerollMovie"}, +{ 0x202f8, "AbortPrePrerollMovie"}, +{ 0x202f9, "QTTempNewHandle"}, +{ 0x202fa, "CreateShortcutMovieFile"}, +{ 0x202fe, "QTAltGetComputerSpeed"}, +{ 0x20300, "GetMovieProgressProc"}, +{ 0x20302, "AddMovieExecuteWiredActionsProc"}, +{ 0x20303, "RemoveMovieExecuteWiredActionsProc"}, +{ 0x20304, "MovieExecuteWiredActions"}, +{ 0x20310, "QTScheduledBandwidthRequest"}, +{ 0x20311, "QTScheduledBandwidthRelease"}, +{ 0x20314, "GetMovieLoadState"}, +{ 0x20315, "SetMovieAnchorDataRef"}, +{ 0x20316, "GetMovieAnchorDataRef"}, +{ 0x20318, "QTBandwidthRequestForTimeBase"}, +{ 0x20319, "QTParseTextHREF"}, +{ 0x2031b, "QTDoCallBacks"}, +{ 0x2031c, "OpenADataHandler"}, +{ 0x2031d, "QTListNew"}, +{ 0x2031e, "QTListDispose"}, +{ 0x2031f, "QTListElementRefNew"}, +{ 0x20320, "QTListElementRefDispose"}, +{ 0x20321, "QTListElementRefGetList"}, +{ 0x20322, "QTListElementRefClone"}, +{ 0x20323, "QTListInsertNewElement"}, +{ 0x20324, "QTListSetElementDataAs"}, +{ 0x20325, "QTListSetElementName"}, +{ 0x20326, "QTListDeleteElement"}, +{ 0x20327, "QTListCutSublist"}, +{ 0x20328, "QTListCopySublist"}, +{ 0x20329, "QTListPasteSublist"}, +{ 0x2032a, "QTListDeleteSublist"}, +{ 0x2032b, "QTListSetMatchingElementData"}, +{ 0x2032c, "QTListCountChildElements"}, +{ 0x2032d, "QTListFindRootElement"}, +{ 0x2032e, "QTListFindParentElement"}, +{ 0x2032f, "QTListFindElementByName"}, +{ 0x20330, "QTListFindElementByIndex"}, +{ 0x20331, "QTListFindChildElementByPathName"}, +{ 0x20332, "QTListGetElementName"}, +{ 0x20333, "QTListGetElementPathName"}, +{ 0x20334, "QTListGetElementTypeAndSize"}, +{ 0x20335, "QTListGetElementIndex"}, +{ 0x20336, "QTListInsertNewAttribute"}, +{ 0x20337, "QTListCopyElementDataToPtr"}, +{ 0x20338, "QTListValidateDataType"}, +{ 0x20339, "QTListWriteToXML"}, +{ 0x2033a, "QTListReadFromXML"}, +{ 0x2033e, "CanQuickTimeOpenFile"}, +{ 0x2033f, "CanQuickTimeOpenDataRef"}, +{ 0x20340, "SetMovieVideoOutput"}, +{ 0x20344, "AddClonedTrackToMovie"}, +{ 0x20347, "QTGetWallClockTimeBase"}, +{ 0x2034f, "QTListDeleteAttribute"}, +{ 0x20350, "QTListCountAttributes"}, +{ 0x20351, "QTListFindAttributeByIndex"}, +{ 0x20352, "QTListFindAttributeByName"}, +{ 0x20353, "QTListFindAttributeParentElement"}, +{ 0x20354, "QTListSetAttributeDataAs"}, +{ 0x20355, "QTListSetAttributeName"}, +{ 0x20356, "QTListGetAttributeName"}, +{ 0x20357, "QTListAttributeRefNew"}, +{ 0x20358, "QTListAttributeRefDispose"}, +{ 0x20359, "QTListAttributeRefClone"}, +{ 0x2035a, "QTListGetAttributeTypeAndSize"}, +{ 0x2035b, "QTListGetAttributeIndex"}, +{ 0x2035c, "QTListCopyAttributeDataToPtr"}, +{ 0x190002, "NewPalette"}, +{ 0x190003, "GetNewPalette"}, +{ 0x190004, "DisposePalette"}, +{ 0x190005, "ActivatePalette"}, +{ 0x190006, "SetPalette"}, +{ 0x190007, "NSetPalette"}, +{ 0x190008, "GetPalette"}, +{ 0x190009, "CopyPalette"}, +{ 0x19000a, "PmForeColor"}, +{ 0x19000b, "PmBackColor"}, +{ 0x19000e, "GetEntryColor"}, +{ 0x19000f, "SetEntryColor"}, +{ 0x190010, "GetEntryUsage"}, +{ 0x190011, "SetEntryUsage"}, +{ 0x190012, "CTab2Palette"}, +{ 0x190013, "Palette2CTab"}, +{ 0x190014, "Entry2Index"}, +{ 0x190016, "MacResizePalette"}, +{ 0x190017, "SaveFore"}, +{ 0x190018, "SaveBack"}, +{ 0x190019, "RestoreFore"}, +{ 0x19001a, "RestoreBack"}, +{ 0x19001d, "PMgrVersion"}, +{ 0x19001e, "SetPaletteUpdates"}, +{ 0x19001f, "GetPaletteUpdates"}, +{ 0x190020, "GetGray"}, |