static HRESULT WINAPI MediaStreamFilterImpl_Run(IMediaStreamFilter *iface, REFERENCE_TIME start) { FIXME("(%p)->(%s): Stub!\n", iface, wine_dbgstr_longlong(start)); return E_NOTIMPL; }
static HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRACK8 iface, void* pStateData, REFERENCE_TIME rtStart, REFERENCE_TIME rtEnd, REFERENCE_TIME rtOffset, DWORD dwFlags, IDirectMusicPerformance* pPerf, IDirectMusicSegmentState* pSegSt, DWORD dwVirtualID) { ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface); FIXME("(%p, %p, 0x%s, 0x%s, 0x%s, %d, %p, %p, %d): stub\n", This, pStateData, wine_dbgstr_longlong(rtStart), wine_dbgstr_longlong(rtEnd), wine_dbgstr_longlong(rtOffset), dwFlags, pPerf, pSegSt, dwVirtualID); return S_OK; }
static BOOL arm_stack_walk(struct cpu_stack_walk* csw, LPSTACKFRAME64 frame, CONTEXT* context) { unsigned deltapc = curr_count <= 1 ? 0 : 4; /* sanity check */ if (curr_mode >= stm_done) return FALSE; TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s\n", wine_dbgstr_addr(&frame->AddrPC), wine_dbgstr_addr(&frame->AddrFrame), wine_dbgstr_addr(&frame->AddrReturn), wine_dbgstr_addr(&frame->AddrStack), curr_mode == stm_start ? "start" : "ARM", wine_dbgstr_longlong(curr_count)); if (curr_mode == stm_start) { if ((frame->AddrPC.Mode == AddrModeFlat) && (frame->AddrFrame.Mode != AddrModeFlat)) { WARN("Bad AddrPC.Mode / AddrFrame.Mode combination\n"); goto done_err; } /* Init done */ set_curr_mode(stm_arm); frame->AddrReturn.Mode = frame->AddrStack.Mode = AddrModeFlat; /* don't set up AddrStack on first call. Either the caller has set it up, or * we will get it in the next frame */ memset(&frame->AddrBStore, 0, sizeof(frame->AddrBStore)); } else { if (context->Sp != frame->AddrStack.Offset) FIXME("inconsistent Stack Pointer\n"); if (context->Pc != frame->AddrPC.Offset) FIXME("inconsistent Program Counter\n"); if (frame->AddrReturn.Offset == 0) goto done_err; if (!fetch_next_frame(csw, context, frame->AddrPC.Offset - deltapc)) goto done_err; } memset(&frame->Params, 0, sizeof(frame->Params)); /* set frame information */ frame->AddrStack.Offset = context->Sp; frame->AddrReturn.Offset = context->Lr; frame->AddrFrame.Offset = context->Fp; frame->AddrPC.Offset = context->Pc; frame->Far = TRUE; frame->Virtual = TRUE; inc_curr_count(); TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s FuncTable=%p\n", wine_dbgstr_addr(&frame->AddrPC), wine_dbgstr_addr(&frame->AddrFrame), wine_dbgstr_addr(&frame->AddrReturn), wine_dbgstr_addr(&frame->AddrStack), curr_mode == stm_start ? "start" : "ARM", wine_dbgstr_longlong(curr_count), frame->FuncTableEntry); return TRUE; done_err: set_curr_mode(stm_done); return FALSE; }
/****************************************************************************** * EventWrite [ADVAPI32.@] */ ULONG WINAPI EventWrite( REGHANDLE handle, PCEVENT_DESCRIPTOR descriptor, ULONG count, PEVENT_DATA_DESCRIPTOR data ) { FIXME("%s, %p, %u, %p: stub\n", wine_dbgstr_longlong(handle), descriptor, count, data); return ERROR_SUCCESS; }
/****************************************************************************** * TraceMessageVa [ADVAPI32.@] */ ULONG WINAPI TraceMessageVa( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number, __ms_va_list args ) { FIXME("(%s %x %s %d) : stub\n", wine_dbgstr_longlong(handle), flags, debugstr_guid(guid), number); return ERROR_SUCCESS; }
/****************************************************************************** * UnregisterTraceGuids [ADVAPI32.@] * * See RegisterTraceGuids * * FIXME * Stub. */ ULONG WINAPI UnregisterTraceGuids( TRACEHANDLE RegistrationHandle ) { FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle)); return ERROR_CALL_NOT_IMPLEMENTED; }
/****************************************************************************** * EventEnabled [ADVAPI32.@] * */ BOOLEAN WINAPI EventEnabled( REGHANDLE handle, PCEVENT_DESCRIPTOR descriptor ) { FIXME("(%s, %p): stub\n", wine_dbgstr_longlong(handle), descriptor); return FALSE; }
static HRESULT WINAPI IDirectMusicPerformance8Impl_ReferenceToMusicTime (LPDIRECTMUSICPERFORMANCE8 iface, REFERENCE_TIME rtTime, MUSIC_TIME* pmtTime) { IDirectMusicPerformance8Impl *This = (IDirectMusicPerformance8Impl *)iface; FIXME("(%p, 0x%s, %p): stub\n", This, wine_dbgstr_longlong(rtTime), pmtTime); return S_OK; }
static HRESULT WINAPI IDirectMusicPerformance8Impl_AdjustTime (LPDIRECTMUSICPERFORMANCE8 iface, REFERENCE_TIME rtAmount) { IDirectMusicPerformance8Impl *This = (IDirectMusicPerformance8Impl *)iface; FIXME("(%p, 0x%s): stub\n", This, wine_dbgstr_longlong(rtAmount)); return S_OK; }
static HRESULT WINAPI IDirectMusicSynth8Impl_StopVoice (LPDIRECTMUSICSYNTH8 iface, REFERENCE_TIME rt, DWORD dwVoiceId) { IDirectMusicSynth8Impl *This = (IDirectMusicSynth8Impl *)iface; FIXME("(%p, 0x%s, %d): stub\n", This, wine_dbgstr_longlong(rt), dwVoiceId); return S_OK; }
static HRESULT WINAPI IDirectMusicSynth8Impl_PlayBuffer (LPDIRECTMUSICSYNTH8 iface, REFERENCE_TIME rt, LPBYTE pbBuffer, DWORD cbBuffer) { IDirectMusicSynth8Impl *This = (IDirectMusicSynth8Impl *)iface; FIXME("(%p, 0x%s, %p, %d): stub\n", This, wine_dbgstr_longlong(rt), pbBuffer, cbBuffer); return S_OK; }
static HRESULT WINAPI IDirectMusicSynth8Impl_Render (LPDIRECTMUSICSYNTH8 iface, short* pBuffer, DWORD dwLength, LONGLONG llPosition) { IDirectMusicSynth8Impl *This = (IDirectMusicSynth8Impl *)iface; FIXME("(%p, %p, %d, 0x%s): stub\n", This, pBuffer, dwLength, wine_dbgstr_longlong(llPosition)); return S_OK; }
DECLSPEC_HIDDEN BOOL coff_process_info(const struct msc_debug_info* msc_dbg) { const IMAGE_AUX_SYMBOL* aux; const IMAGE_COFF_SYMBOLS_HEADER* coff; const IMAGE_LINENUMBER* coff_linetab; const IMAGE_LINENUMBER* linepnt; const char* coff_strtab; const IMAGE_SYMBOL* coff_sym; const IMAGE_SYMBOL* coff_symbols; struct CoffFileSet coff_files; int curr_file_idx = -1; unsigned int i; int j; int k; int l; int linetab_indx; const char* nampnt; int naux; BOOL ret = FALSE; ULONG64 addr; TRACE("Processing COFF symbols...\n"); assert(sizeof(IMAGE_SYMBOL) == IMAGE_SIZEOF_SYMBOL); assert(sizeof(IMAGE_LINENUMBER) == IMAGE_SIZEOF_LINENUMBER); coff_files.files = NULL; coff_files.nfiles = coff_files.nfiles_alloc = 0; coff = (const IMAGE_COFF_SYMBOLS_HEADER*)msc_dbg->root; coff_symbols = (const IMAGE_SYMBOL*)((const char *)coff + coff->LvaToFirstSymbol); coff_linetab = (const IMAGE_LINENUMBER*)((const char *)coff + coff->LvaToFirstLinenumber); coff_strtab = (const char*)(coff_symbols + coff->NumberOfSymbols); linetab_indx = 0; for (i = 0; i < coff->NumberOfSymbols; i++) { coff_sym = coff_symbols + i; naux = coff_sym->NumberOfAuxSymbols; if (coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE) { curr_file_idx = coff_add_file(&coff_files, msc_dbg->module, (const char*)(coff_sym + 1)); TRACE("New file %s\n", (const char*)(coff_sym + 1)); i += naux; continue; } if (curr_file_idx < 0) { assert(coff_files.nfiles == 0 && coff_files.nfiles_alloc == 0); curr_file_idx = coff_add_file(&coff_files, msc_dbg->module, "<none>"); TRACE("New file <none>\n"); } /* * This guy marks the size and location of the text section * for the current file. We need to keep track of this so * we can figure out what file the different global functions * go with. */ if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux != 0 && coff_sym->Type == 0 && coff_sym->SectionNumber == 1) { aux = (const IMAGE_AUX_SYMBOL*) (coff_sym + 1); if (coff_files.files[curr_file_idx].linetab_offset != -1) { /* * Save this so we can still get the old name. */ const char* fn; fn = source_get(msc_dbg->module, coff_files.files[curr_file_idx].compiland->source); TRACE("Duplicating sect from %s: %x %x %x %d %d\n", fn, aux->Section.Length, aux->Section.NumberOfRelocations, aux->Section.NumberOfLinenumbers, aux->Section.Number, aux->Section.Selection); TRACE("More sect %d %s %08x %d %d %d\n", coff_sym->SectionNumber, coff_get_name(coff_sym, coff_strtab), coff_sym->Value, coff_sym->Type, coff_sym->StorageClass, coff_sym->NumberOfAuxSymbols); /* * Duplicate the file entry. We have no way to describe * multiple text sections in our current way of handling things. */ coff_add_file(&coff_files, msc_dbg->module, fn); } else { TRACE("New text sect from %s: %x %x %x %d %d\n", source_get(msc_dbg->module, coff_files.files[curr_file_idx].compiland->source), aux->Section.Length, aux->Section.NumberOfRelocations, aux->Section.NumberOfLinenumbers, aux->Section.Number, aux->Section.Selection); } if (coff_files.files[curr_file_idx].startaddr > coff_sym->Value) { coff_files.files[curr_file_idx].startaddr = coff_sym->Value; } if (coff_files.files[curr_file_idx].endaddr < coff_sym->Value + aux->Section.Length) { coff_files.files[curr_file_idx].endaddr = coff_sym->Value + aux->Section.Length; } coff_files.files[curr_file_idx].linetab_offset = linetab_indx; coff_files.files[curr_file_idx].linecnt = aux->Section.NumberOfLinenumbers; linetab_indx += aux->Section.NumberOfLinenumbers; i += naux; continue; } if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0 && coff_sym->SectionNumber == 1) { DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress; /* * This is a normal static function when naux == 0. * Just register it. The current file is the correct * one in this instance. */ nampnt = coff_get_name(coff_sym, coff_strtab); TRACE("\tAdding static symbol %s\n", nampnt); /* FIXME: was adding symbol to this_file ??? */ coff_add_symbol(&coff_files.files[curr_file_idx], &symt_new_function(msc_dbg->module, coff_files.files[curr_file_idx].compiland, nampnt, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, 0 /* FIXME */, NULL /* FIXME */)->symt); i += naux; continue; } if (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL && ISFCN(coff_sym->Type) && coff_sym->SectionNumber > 0) { struct symt_compiland* compiland = NULL; DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress; nampnt = coff_get_name(coff_sym, coff_strtab); TRACE("%d: %s %s\n", i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value), nampnt); TRACE("\tAdding global symbol %s (sect=%s)\n", nampnt, msc_dbg->sectp[coff_sym->SectionNumber - 1].Name); /* * Now we need to figure out which file this guy belongs to. */ for (j = 0; j < coff_files.nfiles; j++) { if (coff_files.files[j].startaddr <= base + coff_sym->Value && coff_files.files[j].endaddr > base + coff_sym->Value) { compiland = coff_files.files[j].compiland; break; } } if (j < coff_files.nfiles) { coff_add_symbol(&coff_files.files[j], &symt_new_function(msc_dbg->module, compiland, nampnt, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, 0 /* FIXME */, NULL /* FIXME */)->symt); } else { symt_new_function(msc_dbg->module, NULL, nampnt, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, 0 /* FIXME */, NULL /* FIXME */); } i += naux; continue; } if (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL && coff_sym->SectionNumber > 0) { DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress; struct location loc; /* * Similar to above, but for the case of data symbols. * These aren't treated as entrypoints. */ nampnt = coff_get_name(coff_sym, coff_strtab); TRACE("%d: %s %s\n", i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value), nampnt); TRACE("\tAdding global data symbol %s\n", nampnt); /* * Now we need to figure out which file this guy belongs to. */ loc.kind = loc_absolute; loc.reg = 0; loc.offset = msc_dbg->module->module.BaseOfImage + base + coff_sym->Value; symt_new_global_variable(msc_dbg->module, NULL, nampnt, TRUE /* FIXME */, loc, 0 /* FIXME */, NULL /* FIXME */); i += naux; continue; } if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0) { /* * Ignore these. They don't have anything to do with * reality. */ i += naux; continue; } TRACE("Skipping unknown entry '%s' %d %d %d\n", coff_get_name(coff_sym, coff_strtab), coff_sym->StorageClass, coff_sym->SectionNumber, naux); /* * For now, skip past the aux entries. */ i += naux; } if (coff_files.files != NULL) { /* * OK, we now should have a list of files, and we should have a list * of entrypoints. We need to sort the entrypoints so that we are * able to tie the line numbers with the given functions within the * file. */ for (j = 0; j < coff_files.nfiles; j++) { if (coff_files.files[j].entries != NULL) { qsort(coff_files.files[j].entries, coff_files.files[j].neps, sizeof(struct symt*), symt_cmp_addr); } } /* * Now pick apart the line number tables, and attach the entries * to the given functions. */ for (j = 0; j < coff_files.nfiles; j++) { l = 0; if (coff_files.files[j].neps != 0) { for (k = 0; k < coff_files.files[j].linecnt; k++) { linepnt = coff_linetab + coff_files.files[j].linetab_offset + k; /* * If we have spilled onto the next entrypoint, then * bump the counter.. */ for (;;) { if (l+1 >= coff_files.files[j].neps) break; symt_get_address(coff_files.files[j].entries[l+1], &addr); if (((msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress) < addr)) break; l++; } if (coff_files.files[j].entries[l+1]->tag == SymTagFunction) { /* * Add the line number. This is always relative to the * start of the function, so we need to subtract that offset * first. */ symt_get_address(coff_files.files[j].entries[l+1], &addr); symt_add_func_line(msc_dbg->module, (struct symt_function*)coff_files.files[j].entries[l+1], coff_files.files[j].compiland->source, linepnt->Linenumber, msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress - addr); } } } } for (j = 0; j < coff_files.nfiles; j++) { HeapFree(GetProcessHeap(), 0, coff_files.files[j].entries); } HeapFree(GetProcessHeap(), 0, coff_files.files); msc_dbg->module->module.SymType = SymCoff; /* FIXME: we could have a finer grain here */ msc_dbg->module->module.LineNumbers = TRUE; msc_dbg->module->module.GlobalSymbols = TRUE; msc_dbg->module->module.TypeInfo = FALSE; msc_dbg->module->module.SourceIndexed = TRUE; msc_dbg->module->module.Publics = TRUE; ret = TRUE; } return ret; }
static HRESULT WINAPI MediaStreamFilterImpl_WaitUntil(IMediaStreamFilter* iface, REFERENCE_TIME WaitStreamTime) { FIXME("(%p)->(%s): Stub!\n", iface, wine_dbgstr_longlong(WaitStreamTime)); return E_NOTIMPL; }
/****************************************************************************** * StopTraceA [ADVAPI32.@] * * See StopTraceW. * */ ULONG WINAPI StopTraceA( TRACEHANDLE session, LPCSTR session_name, PEVENT_TRACE_PROPERTIES properties ) { FIXME("(%s, %s, %p) stub\n", wine_dbgstr_longlong(session), debugstr_a(session_name), properties); return ERROR_SUCCESS; }
static HRESULT WINAPI IDirectMusicPerformance8Impl_GetResolvedTime (LPDIRECTMUSICPERFORMANCE8 iface, REFERENCE_TIME rtTime, REFERENCE_TIME* prtResolved, DWORD dwTimeResolveFlags) { IDirectMusicPerformance8Impl *This = (IDirectMusicPerformance8Impl *)iface; FIXME("(%p, 0x%s, %p, %d): stub\n", This, wine_dbgstr_longlong(rtTime), prtResolved, dwTimeResolveFlags); return S_OK; }
/****************************************************************************** * TraceEvent [ADVAPI32.@] */ ULONG WINAPI TraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace ) { FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace); return ERROR_CALL_NOT_IMPLEMENTED; }
static HRESULT WINAPI IDirectMusicPerformance8Impl_StopEx (LPDIRECTMUSICPERFORMANCE8 iface, IUnknown* pObjectToStop, __int64 i64StopTime, DWORD dwFlags) { IDirectMusicPerformance8Impl *This = (IDirectMusicPerformance8Impl *)iface; FIXME("(%p, %p, 0x%s, %d): stub\n", This, pObjectToStop, wine_dbgstr_longlong(i64StopTime), dwFlags); return S_OK; }
/****************************************************************************** * EventUnregister [ADVAPI32.@] */ ULONG WINAPI EventUnregister( REGHANDLE handle ) { FIXME("%s: stub\n", wine_dbgstr_longlong(handle)); return ERROR_SUCCESS; }
/*********************************************************************** * SymLoadModuleExW (DBGHELP.@) */ DWORD64 WINAPI SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageName, PCWSTR wModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll, PMODLOAD_DATA Data, DWORD Flags) { struct process* pcs; struct module* module = NULL; TRACE("(%p %p %s %s %s %08x %p %08x)\n", hProcess, hFile, debugstr_w(wImageName), debugstr_w(wModuleName), wine_dbgstr_longlong(BaseOfDll), SizeOfDll, Data, Flags); if (Data) FIXME("Unsupported load data parameter %p for %s\n", Data, debugstr_w(wImageName)); if (!validate_addr64(BaseOfDll)) return FALSE; if (!(pcs = process_find_by_handle(hProcess))) return FALSE; if (Flags & SLMFLAG_VIRTUAL) { if (!wImageName) return FALSE; module = module_new(pcs, wImageName, module_get_type_by_name(wImageName), TRUE, BaseOfDll, SizeOfDll, 0, 0); if (!module) return FALSE; if (wModuleName) module_set_module(module, wModuleName); module->module.SymType = SymVirtual; return TRUE; } if (Flags & ~(SLMFLAG_VIRTUAL)) FIXME("Unsupported Flags %08x for %s\n", Flags, debugstr_w(wImageName)); #ifndef DBGHELP_STATIC_LIB refresh_module_list(pcs); #endif /* this is a Wine extension to the API just to redo the synchronisation */ if (!wImageName && !hFile) return 0; /* check if the module is already loaded, or if it's a builtin PE module with * an containing ELF module */ if (wImageName) { module = module_is_already_loaded(pcs, wImageName); if (!module && module_is_container_loaded(pcs, wImageName, BaseOfDll)) { /* force the loading of DLL as builtin */ module = pe_load_builtin_module(pcs, wImageName, BaseOfDll, SizeOfDll); } } if (!module) { /* otherwise, try a regular PE module */ if (!(module = pe_load_native_module(pcs, wImageName, hFile, BaseOfDll, SizeOfDll)) && wImageName) { /* and finally an ELF or Mach-O module */ #ifndef DBGHELP_STATIC_LIB switch (module_get_type_by_name(wImageName)) { case DMT_ELF: module = elf_load_module(pcs, wImageName, BaseOfDll); break; case DMT_MACHO: module = macho_load_module(pcs, wImageName, BaseOfDll); break; default: /* Ignored */ break; } #endif } } if (!module) { WARN("Couldn't locate %s\n", debugstr_w(wImageName)); return 0; } module->module.NumSyms = module->ht_symbols.num_elts; /* by default module_new fills module.ModuleName from a derivation * of LoadedImageName. Overwrite it, if we have better information */ if (wModuleName) module_set_module(module, wModuleName); if (wImageName) lstrcpynW(module->module.ImageName, wImageName, sizeof(module->module.ImageName) / sizeof(WCHAR)); return module->module.BaseOfImage; }
/****************************************************************************** * EventProviderEnabled [ADVAPI32.@] * */ BOOLEAN WINAPI EventProviderEnabled( REGHANDLE handle, UCHAR level, ULONGLONG keyword ) { FIXME("%s, %u, %s: stub\n", wine_dbgstr_longlong(handle), level, wine_dbgstr_longlong(keyword)); return FALSE; }
static HRESULT QT_Process_Movie(QTSplitter* filter) { HRESULT hr = S_OK; OSErr err; WineDataRefRecord ptrDataRefRec; Handle dataRef = NULL; Track trk; short id = 0; DWORD tid; LONGLONG time; TRACE("Trying movie connect\n"); ptrDataRefRec.pReader = filter->pInputPin.pReader; ptrDataRefRec.streamSubtype = filter->pInputPin.subType; PtrToHand( &ptrDataRefRec, &dataRef, sizeof(WineDataRefRecord)); err = NewMovieFromDataRef(&filter->pQTMovie, newMovieActive|newMovieDontInteractWithUser|newMovieDontAutoUpdateClock|newMovieDontAskUnresolvedDataRefs|newMovieAsyncOK, &id, dataRef, 'WINE'); DisposeHandle(dataRef); if (err != noErr) { FIXME("QuickTime cannot handle media type(%i)\n",err); return VFW_E_TYPE_NOT_ACCEPTED; } PrePrerollMovie(filter->pQTMovie, 0, fixed1, NULL, NULL); PrerollMovie(filter->pQTMovie, 0, fixed1); GoToBeginningOfMovie(filter->pQTMovie); SetMovieActive(filter->pQTMovie,TRUE); if (GetMovieLoadState(filter->pQTMovie) < kMovieLoadStateLoaded) MoviesTask(filter->pQTMovie,100); trk = GetMovieIndTrackType(filter->pQTMovie, 1, VisualMediaCharacteristic, movieTrackCharacteristic | movieTrackEnabledOnly); TRACE("%p is a video track\n",trk); if (trk) hr = QT_Process_Video_Track(filter, trk); if (FAILED(hr)) return hr; trk = GetMovieIndTrackType(filter->pQTMovie, 1, AudioMediaCharacteristic, movieTrackCharacteristic | movieTrackEnabledOnly); TRACE("%p is an audio track\n",trk); if (trk) hr = QT_Process_Audio_Track(filter, trk); time = GetMovieDuration(filter->pQTMovie); filter->movie_scale = GetMovieTimeScale(filter->pQTMovie); filter->sourceSeeking.llDuration = ((double)time / filter->movie_scale) * 10000000; filter->sourceSeeking.llStop = filter->sourceSeeking.llDuration; TRACE("Movie duration is %s\n",wine_dbgstr_longlong(filter->sourceSeeking.llDuration)); filter->loaderThread = CreateThread(NULL, 0, QTSplitter_loading_thread, filter, 0, &tid); if (filter->loaderThread) TRACE("Created loading thread 0x%08x\n", tid); filter->splitterThread = CreateThread(NULL, 0, QTSplitter_thread, filter, 0, &tid); if (filter->splitterThread) TRACE("Created processing thread 0x%08x\n", tid); else hr = HRESULT_FROM_WIN32(GetLastError()); return hr; }
/****************************************************************************** * QueryTraceW [ADVAPI32.@] */ ULONG WINAPI QueryTraceW( TRACEHANDLE handle, LPCWSTR sessionname, PEVENT_TRACE_PROPERTIES properties ) { FIXME("%s %s %p: stub\n", wine_dbgstr_longlong(handle), debugstr_w(sessionname), properties); return ERROR_CALL_NOT_IMPLEMENTED; }
static DWORD WINAPI DSoundAdviseThread(LPVOID lpParam) { DSoundRenderImpl *This = lpParam; struct dsoundrender_timer head = {NULL}; MSG msg; TRACE("(%p): Main Loop\n", This); PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE); SetEvent(This->thread_wait); while (1) { HRESULT hr; REFERENCE_TIME curtime = 0; BOOL ret; struct dsoundrender_timer *prev = &head, *cur; hr = IReferenceClock_GetTime(&This->IReferenceClock_iface, &curtime); if (SUCCEEDED(hr)) { TRACE("Time: %s\n", wine_dbgstr_longlong(curtime)); while (prev->next) { cur = prev->next; if (cur->start > curtime) { TRACE("Skipping %p\n", cur); prev = cur; } else if (cur->periodicity) { while (cur->start <= curtime) { cur->start += cur->periodicity; ReleaseSemaphore(cur->handle, 1, NULL); } prev = cur; } else { struct dsoundrender_timer *next = cur->next; TRACE("Firing %p %s < %s\n", cur, wine_dbgstr_longlong(cur->start), wine_dbgstr_longlong(curtime)); SetEvent(cur->handle); HeapFree(GetProcessHeap(), 0, cur); prev->next = next; } } } if (!head.next) ret = GetMessageW(&msg, INVALID_HANDLE_VALUE, WM_APP, WM_APP + 4); else ret = PeekMessageW(&msg, INVALID_HANDLE_VALUE, WM_APP, WM_APP + 4, PM_REMOVE); while (ret) { switch (LOWORD(msg.message) - WM_APP) { case 0: TRACE("Exiting\n"); return 0; case 1: case 2: { struct dsoundrender_timer *t = (struct dsoundrender_timer *)msg.wParam; if (LOWORD(msg.message) - WM_APP == 1) TRACE("Adding one-shot timer %p\n", t); else TRACE("Adding periodic timer %p\n", t); t->next = head.next; head.next = t; break; } case 3: prev = &head; while (prev->next) { cur = prev->next; if (cur->cookie == msg.wParam) { struct dsoundrender_timer *next = cur->next; HeapFree(GetProcessHeap(), 0, cur); prev->next = next; break; } prev = cur; } break; } ret = PeekMessageW(&msg, INVALID_HANDLE_VALUE, WM_APP, WM_APP + 4, PM_REMOVE); } MsgWaitForMultipleObjects(0, NULL, 5, QS_POSTMESSAGE, 0); } return 0; }
/****************************************************************************** * CloseTrace [ADVAPI32.@] */ ULONG WINAPI CloseTrace( TRACEHANDLE handle ) { FIXME("%s: stub\n", wine_dbgstr_longlong(handle)); return ERROR_INVALID_HANDLE; }
/****************************************************************************** * GetTraceEnableFlags [ADVAPI32.@] */ ULONG WINAPI GetTraceEnableFlags( TRACEHANDLE handle ) { FIXME("(%s) stub\n", wine_dbgstr_longlong(handle)); return 0; }
static HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) { ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface); FIXME("(%p, %s, 0x%s, %p, %p, %d): stub\n", This, debugstr_dmguid(rguidType), wine_dbgstr_longlong(rtTime), pParam, pStateData, dwFlags); return S_OK; }
/****************************************************************************** * GetTraceEnableLevel [ADVAPI32.@] */ UCHAR WINAPI GetTraceEnableLevel( TRACEHANDLE handle ) { FIXME("(%s) stub\n", wine_dbgstr_longlong(handle)); return TRACE_LEVEL_VERBOSE; }
/****************************************************************************** * ControlTraceA [ADVAPI32.@] * * See ControlTraceW. * */ ULONG WINAPI ControlTraceA( TRACEHANDLE hSession, LPCSTR SessionName, PEVENT_TRACE_PROPERTIES Properties, ULONG control ) { FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(hSession), debugstr_a(SessionName), Properties, control); return ERROR_SUCCESS; }
/****************************************************************** * macho_finish_stabs * * Integrate the non-debugging symbols we've gathered into the * symbols that were generated during stabs parsing. */ static void macho_finish_stabs(struct module* module, struct hash_table* ht_symtab) { struct hash_table_iter hti_ours; struct symtab_elt* ste; BOOL adjusted = FALSE; TRACE("(%p, %p)\n", module, ht_symtab); /* For each of our non-debugging symbols, see if it can provide some * missing details to one of the module's known symbols. */ hash_table_iter_init(ht_symtab, &hti_ours, NULL); while ((ste = hash_table_iter_up(&hti_ours))) { struct hash_table_iter hti_modules; void* ptr; struct symt_ht* sym; struct symt_function* func; struct symt_data* data; hash_table_iter_init(&module->ht_symbols, &hti_modules, ste->ht_elt.name); while ((ptr = hash_table_iter_up(&hti_modules))) { sym = GET_ENTRY(ptr, struct symt_ht, hash_elt); if (strcmp(sym->hash_elt.name, ste->ht_elt.name)) continue; switch (sym->symt.tag) { case SymTagFunction: func = (struct symt_function*)sym; if (func->address == module->format_info[DFI_MACHO]->u.macho_info->load_addr) { TRACE("Adjusting function %p/%s!%s from 0x%08lx to 0x%08lx\n", func, debugstr_w(module->module.ModuleName), sym->hash_elt.name, func->address, ste->addr); func->address = ste->addr; adjusted = TRUE; } if (func->address == ste->addr) ste->used = 1; break; case SymTagData: data = (struct symt_data*)sym; switch (data->kind) { case DataIsGlobal: case DataIsFileStatic: if (data->u.var.offset == module->format_info[DFI_MACHO]->u.macho_info->load_addr) { TRACE("Adjusting data symbol %p/%s!%s from 0x%08lx to 0x%08lx\n", data, debugstr_w(module->module.ModuleName), sym->hash_elt.name, data->u.var.offset, ste->addr); data->u.var.offset = ste->addr; adjusted = TRUE; } if (data->u.var.offset == ste->addr) { enum DataKind new_kind; new_kind = ste->is_global ? DataIsGlobal : DataIsFileStatic; if (data->kind != new_kind) { WARN("Changing kind for %p/%s!%s from %d to %d\n", sym, debugstr_w(module->module.ModuleName), sym->hash_elt.name, (int)data->kind, (int)new_kind); data->kind = new_kind; adjusted = TRUE; } ste->used = 1; } break; default:; } break; default: TRACE("Ignoring tag %u\n", sym->symt.tag); break; } } } if (adjusted) { /* since we may have changed some addresses, mark the module to be resorted */ module->sortlist_valid = FALSE; } /* Mark any of our non-debugging symbols which fall on an already-used * address as "used". This allows us to skip them in the next loop, * below. We do this in separate loops because symt_new_* marks the * list as needing sorting and symt_find_nearest sorts if needed, * causing thrashing. */ if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY)) { hash_table_iter_init(ht_symtab, &hti_ours, NULL); while ((ste = hash_table_iter_up(&hti_ours))) { struct symt_ht* sym; ULONG64 addr; if (ste->used) continue; sym = symt_find_nearest(module, ste->addr); if (sym) symt_get_info(module, &sym->symt, TI_GET_ADDRESS, &addr); if (sym && ste->addr == addr) { ULONG64 size = 0; DWORD kind = -1; ste->used = 1; /* If neither symbol has a correct size (ours never does), we * consider them both to be markers. No warning is needed in * that case. * Also, we check that we don't have two symbols, one local, the other * global, which is legal. */ symt_get_info(module, &sym->symt, TI_GET_LENGTH, &size); symt_get_info(module, &sym->symt, TI_GET_DATAKIND, &kind); if (size && kind == (ste->is_global ? DataIsGlobal : DataIsFileStatic)) FIXME("Duplicate in %s: %s<%08lx> %s<%s-%s>\n", debugstr_w(module->module.ModuleName), ste->ht_elt.name, ste->addr, sym->hash_elt.name, wine_dbgstr_longlong(addr), wine_dbgstr_longlong(size)); } } } /* For any of our remaining non-debugging symbols which have no match * among the module's known symbols, add them as new symbols. */ hash_table_iter_init(ht_symtab, &hti_ours, NULL); while ((ste = hash_table_iter_up(&hti_ours))) { if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY) && !ste->used) { if (ste->is_code) { symt_new_function(module, ste->compiland, ste->ht_elt.name, ste->addr, 0, NULL); } else { symt_new_global_variable(module, ste->compiland, ste->ht_elt.name, !ste->is_global, ste->addr, 0, NULL); } ste->used = 1; } if (ste->is_public && !(dbghelp_options & SYMOPT_NO_PUBLICS)) { symt_new_public(module, ste->compiland, ste->ht_elt.name, ste->addr, 0); } } }