HRESULT __RPC_STUB ICommand_Execute_Stub(ICommand* This, IUnknown *pUnkOuter, REFIID riid, HACCESSOR hAccessor, DB_UPARAMS cParamSets, GUID *pGuid, ULONG ulGuidOffset, RMTPACK *pInputParams, RMTPACK *pOutputParams, DBCOUNTITEM cBindings, DBBINDING *rgBindings, DBSTATUS *rgStatus, DBROWCOUNT *pcRowsAffected, IUnknown **ppRowset) { IWineRowServer *rowset_server; IMarshal *marshal; IUnknown *obj = NULL; HRESULT hr; TRACE("(%p)->(%p, %s, %08lx, %d, %p, %d, %p, %p, %d, %p, %p, %p, %p): stub\n", This, pUnkOuter, debugstr_guid(riid), hAccessor, cParamSets, pGuid, ulGuidOffset, pInputParams, pOutputParams, cBindings, rgBindings, rgStatus, pcRowsAffected, ppRowset); *ppRowset = NULL; hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&rowset_server); if(FAILED(hr)) return hr; IWineRowServer_GetMarshal(rowset_server, &marshal); hr = ICommand_Execute(This, (IUnknown*)marshal, &IID_IUnknown, NULL, pcRowsAffected, &obj); IMarshal_Release(marshal); if(FAILED(hr)) { IWineRowServer_Release(rowset_server); return hr; } IWineRowServer_SetInnerUnk(rowset_server, obj); hr = IUnknown_QueryInterface(obj, riid, (void**)ppRowset); IUnknown_Release(obj); return hr; }
static HRESULT WINAPI xslprocessor_put_input( IXSLProcessor *iface, VARIANT input ) { xslprocessor *This = impl_from_IXSLProcessor( iface ); IXMLDOMNode *input_node; HRESULT hr; TRACE("(%p)->(%s)\n", This, debugstr_variant(&input)); /* try IXMLDOMNode directly first */ if (V_VT(&input) == VT_UNKNOWN) hr = IUnknown_QueryInterface(V_UNKNOWN(&input), &IID_IXMLDOMNode, (void**)&input_node); else if (V_VT(&input) == VT_DISPATCH) hr = IDispatch_QueryInterface(V_DISPATCH(&input), &IID_IXMLDOMNode, (void**)&input_node); else { IXMLDOMDocument *doc; hr = DOMDocument_create(MSXML_DEFAULT, (void**)&doc); if (hr == S_OK) { VARIANT_BOOL b; hr = IXMLDOMDocument_load(doc, input, &b); if (hr == S_OK) hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&input_node); IXMLDOMDocument_Release(doc); } } if (hr == S_OK) { if (This->input) IXMLDOMNode_Release(This->input); This->input = input_node; } return hr; }
/* Initialize the test texthost structure */ static BOOL init_texthost(ITextServices **txtserv, ITextHost **ret) { ITextHostTestImpl *dummyTextHost; IUnknown *init; HRESULT result; dummyTextHost = CoTaskMemAlloc(sizeof(*dummyTextHost)); if (dummyTextHost == NULL) { win_skip("Insufficient memory to create ITextHost interface\n"); return FALSE; } dummyTextHost->ITextHost_iface.lpVtbl = &itextHostVtbl; dummyTextHost->refCount = 1; /* MSDN states that an IUnknown object is returned by CreateTextServices which is then queried to obtain a ITextServices object. */ result = pCreateTextServices(NULL, &dummyTextHost->ITextHost_iface, &init); ok(result == S_OK, "Did not return S_OK when created (result = %x)\n", result); if (result != S_OK) { CoTaskMemFree(dummyTextHost); win_skip("CreateTextServices failed.\n"); return FALSE; } result = IUnknown_QueryInterface(init, pIID_ITextServices, (void**)txtserv); ok((result == S_OK) && (*txtserv != NULL), "Querying interface failed (result = %x, txtserv = %p)\n", result, *txtserv); IUnknown_Release(init); if (!((result == S_OK) && (*txtserv != NULL))) { CoTaskMemFree(dummyTextHost); win_skip("Could not retrieve ITextServices interface\n"); return FALSE; } *ret = &dummyTextHost->ITextHost_iface; return TRUE; }
/*********************************************************************** * RevokeBindStatusCallback (URLMON.@) * * Unregister a bind status callback. * * pbc [I] Binding context * pbsc [I] Callback to unregister * * RETURNS * Success: S_OK. * Failure: E_INVALIDARG, if any argument is invalid */ HRESULT WINAPI RevokeBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc) { BindStatusCallback *holder; IBindStatusCallback *callback; IUnknown *unk; BOOL dorevoke = FALSE; HRESULT hres; TRACE("(%p %p)\n", pbc, pbsc); if (!pbc || !pbsc) return E_INVALIDARG; hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk); if(FAILED(hres)) return S_OK; hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&callback); IUnknown_Release(unk); if(FAILED(hres)) return S_OK; hres = IBindStatusCallback_QueryInterface(callback, &IID_IBindStatusCallbackHolder, (void**)&holder); if(SUCCEEDED(hres)) { if(pbsc == holder->callback) dorevoke = TRUE; IBindStatusCallback_Release(STATUSCLB(holder)); }else if(pbsc == callback) { dorevoke = TRUE; } IBindStatusCallback_Release(callback); if(dorevoke) IBindCtx_RevokeObjectParam(pbc, BSCBHolder); return S_OK; }
static HRESULT WINAPI OleDocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate) { DocHost *This = DOCSITE_THIS(iface); IOleDocument *oledoc; RECT rect; HRESULT hres; TRACE("(%p)->(%p)\n", This, pViewToActivate); hres = IUnknown_QueryInterface(This->document, &IID_IOleDocument, (void**)&oledoc); if(FAILED(hres)) return hres; IOleDocument_CreateView(oledoc, INPLACESITE(This), NULL, 0, &This->view); IOleDocument_Release(oledoc); GetClientRect(This->hwnd, &rect); IOleDocumentView_SetRect(This->view, &rect); hres = IOleDocumentView_Show(This->view, TRUE); return hres; }
/*********************************************************************** * AtlUnadvise [atl100.@] */ HRESULT WINAPI AtlUnadvise(IUnknown *pUnkCP, const IID *iid, DWORD dw) { IConnectionPointContainer *container; IConnectionPoint *cp; HRESULT hres; TRACE("%p %p %d\n", pUnkCP, iid, dw); if(!pUnkCP) return E_INVALIDARG; hres = IUnknown_QueryInterface(pUnkCP, &IID_IConnectionPointContainer, (void**)&container); if(FAILED(hres)) return hres; hres = IConnectionPointContainer_FindConnectionPoint(container, iid, &cp); IConnectionPointContainer_Release(container); if(FAILED(hres)) return hres; hres = IConnectionPoint_Unadvise(cp, dw); IConnectionPoint_Release(cp); return hres; }
static void advise_prop_notif(DocHost *This, BOOL set) { IConnectionPointContainer *cp_container; IConnectionPoint *cp; HRESULT hres; hres = IUnknown_QueryInterface(This->document, &IID_IConnectionPointContainer, (void**)&cp_container); if(FAILED(hres)) return; hres = IConnectionPointContainer_FindConnectionPoint(cp_container, &IID_IPropertyNotifySink, &cp); IConnectionPointContainer_Release(cp_container); if(FAILED(hres)) return; if(set) hres = IConnectionPoint_Advise(cp, (IUnknown*)&This->IPropertyNotifySink_iface, &This->prop_notif_cookie); else hres = IConnectionPoint_Unadvise(cp, This->prop_notif_cookie); IConnectionPoint_Release(cp); if(SUCCEEDED(hres)) This->is_prop_notif = set; }
static HRESULT WINAPI DocumentMgr_Push(ITfDocumentMgr *iface, ITfContext *pic) { DocumentMgr *This = impl_from_ITfDocumentMgr(iface); ITfContext *check; TRACE("(%p) %p\n",This,pic); if (This->contextStack[1]) /* FUll */ return TF_E_STACKFULL; if (!pic || FAILED(IUnknown_QueryInterface(pic,&IID_ITfContext,(LPVOID*) &check))) return E_INVALIDARG; if (This->contextStack[0] == NULL) ITfThreadMgrEventSink_OnInitDocumentMgr(This->ThreadMgrSink,iface); This->contextStack[1] = This->contextStack[0]; This->contextStack[0] = check; Context_Initialize(check, iface); ITfThreadMgrEventSink_OnPushContext(This->ThreadMgrSink,check); return S_OK; }
static HRESULT WINAPI DSCF_CreateInstance(IClassFactory *iface, IUnknown *pOuter, REFIID riid, void **ppobj) { IClassFactoryImpl *This = impl_from_IClassFactory(iface); HRESULT hres = ERROR_SUCCESS; LPUNKNOWN punk; TRACE("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj); if (!ppobj) return E_POINTER; /* Enforce the normal OLE rules regarding interfaces and delegation */ if (pOuter && !IsEqualGUID(riid, &IID_IUnknown)) return E_NOINTERFACE; *ppobj = NULL; punk = This->pfnCreateInstance(pOuter, &hres); if (!punk) { /* No object created, update error if it isn't done already and return */ if (SUCCEEDED(hres)) hres = E_OUTOFMEMORY; return hres; } if (SUCCEEDED(hres)) { hres = IUnknown_QueryInterface(punk, riid, ppobj); } /* Releasing the object. If everything was successful, QueryInterface should have incremented the refcount once more, otherwise this will purge the object. */ IUnknown_Release(punk); return hres; }
static HRESULT ITrayBandSiteImpl_Update(IN OUT ITrayBandSiteImpl *This) { IOleCommandTarget *pOct; HRESULT hRet; hRet = IUnknown_QueryInterface(This->punkInner, &IID_IOleCommandTarget, (PVOID*)&pOct); if (SUCCEEDED(hRet)) { /* Send the DBID_BANDINFOCHANGED command to update the band site */ hRet = IOleCommandTarget_Exec(pOct, &IID_IDeskBand, DBID_BANDINFOCHANGED, 0, NULL, NULL); IOleCommandTarget_Release(pOct); } return hRet; }
void detach_plugin_host(PluginHost *host) { HRESULT hres; TRACE("%p\n", host); if(!host->doc) return; if(host->ip_object) { if(host->ui_active) IOleInPlaceObject_UIDeactivate(host->ip_object); IOleInPlaceObject_InPlaceDeactivate(host->ip_object); } if(host->plugin_unk) { IOleObject *ole_obj; hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IOleObject, (void**)&ole_obj); if(SUCCEEDED(hres)) { if(!host->ip_object) IOleObject_Close(ole_obj, OLECLOSE_NOSAVE); IOleObject_SetClientSite(ole_obj, NULL); IOleObject_Release(ole_obj); } } if(host->element) { host->element->plugin_host = NULL; host->element = NULL; } list_remove(&host->entry); list_init(&host->entry); host->doc = NULL; }
static IDispatchEx *parse_procedure_a(IActiveScriptParse *parser, const char *src) { IActiveScriptParseProcedure2 *parse_proc; IDispatchEx *dispex; IDispatch *disp; BSTR str; HRESULT hres; hres = IUnknown_QueryInterface(parser, &IID_IActiveScriptParseProcedure2, (void**)&parse_proc); ok(hres == S_OK, "Coult not get IActiveScriptParseProcedure2: %08x\n", hres); str = a2bstr(src); hres = IActiveScriptParseProcedure2_64_ParseProcedureText(parse_proc, str, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, &disp); SysFreeString(str); IUnknown_Release(parse_proc); ok(hres == S_OK, "ParseProcedureText failed: %08x\n", hres); ok(disp != NULL, "disp == NULL\n"); hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); IDispatch_Release(dispex); ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres); return dispex; }
HRESULT WINAPI FileSystemBindData_GetFindData(LPBC pbc, WIN32_FIND_DATAW *pfd) { LPUNKNOWN pUnk; IFileSystemBindData *pfsbd = NULL; HRESULT ret; TRACE("%p, %p\n", pbc, pfd); if (!pfd) return E_INVALIDARG; ret = IBindCtx_GetObjectParam(pbc, (LPOLESTR)wFileSystemBindData, &pUnk); if (SUCCEEDED(ret)) { ret = IUnknown_QueryInterface(pUnk, &IID_IFileSystemBindData, (LPVOID *)&pfsbd); if (SUCCEEDED(ret)) { ret = IFileSystemBindData_GetFindData(pfsbd, pfd); IFileSystemBindData_Release(pfsbd); } IUnknown_Release(pUnk); } return ret; }
HRESULT WINAPI TransformFilterImpl_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv) { HRESULT hr; TransformFilter *This = impl_from_IBaseFilter(iface); TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppv); if (IsEqualIID(riid, &IID_IQualityControl)) { *ppv = (IQualityControl*)This->qcimpl; IUnknown_AddRef((IUnknown*)*ppv); return S_OK; } else if (IsEqualIID(riid, &IID_IMediaSeeking) || IsEqualIID(riid, &IID_IMediaPosition)) { return IUnknown_QueryInterface(This->seekthru_unk, riid, ppv); } hr = BaseFilterImpl_QueryInterface(iface, riid, ppv); if (FAILED(hr) && !IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow) && !IsEqualIID(riid, &IID_IAMFilterMiscFlags)) FIXME("No interface for %s!\n", debugstr_guid(riid)); return hr; }
static void test_InternetExplorer(void) { IWebBrowser2 *wb; IUnknown *unk; ULONG ref; HRESULT hres; hres = CoCreateInstance(&CLSID_InternetExplorer, NULL, CLSCTX_SERVER, &IID_IUnknown, (void**)&unk); ok(hres == S_OK, "Could not create InternetExplorer instance: %08x\n", hres); if(hres != S_OK) return; hres = IUnknown_QueryInterface(unk, &IID_IWebBrowser2, (void**)&wb); ok(hres == S_OK, "Could not get IWebBrowser2 interface: %08x\n", hres); test_visible(wb); test_html_window(wb); IWebBrowser2_Release(wb); ref = IUnknown_Release(unk); ok(!ref, "object not destroyed, ref=%u\n", ref); }
static void test_AviMux_QueryInterface(void) { IUnknown *avimux, *unk; HRESULT hr; hr = CoCreateInstance(&CLSID_AviDest, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&avimux); ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG), "couldn't create AVI Mux filter, hr = %08x\n", hr); if(hr != S_OK) { win_skip("AVI Mux filter is not registered\n"); return; } hr = IUnknown_QueryInterface(avimux, &IID_IBaseFilter, (void**)&unk); ok(hr == S_OK, "QueryInterface(IID_IBaseFilter) failed: %x\n", hr); IUnknown_Release(unk); hr = IUnknown_QueryInterface(avimux, &IID_IConfigAviMux, (void**)&unk); ok(hr == S_OK, "QueryInterface(IID_IConfigAviMux) failed: %x\n", hr); IUnknown_Release(unk); hr = IUnknown_QueryInterface(avimux, &IID_IConfigInterleaving, (void**)&unk); ok(hr == S_OK, "QueryInterface(IID_IConfigInterleaving) failed: %x\n", hr); IUnknown_Release(unk); hr = IUnknown_QueryInterface(avimux, &IID_IMediaSeeking, (void**)&unk); ok(hr == S_OK, "QueryInterface(IID_IMediaSeeking) failed: %x\n", hr); IUnknown_Release(unk); hr = IUnknown_QueryInterface(avimux, &IID_IPersistMediaPropertyBag, (void**)&unk); ok(hr == S_OK, "QueryInterface(IID_IPersistMediaPropertyBag) failed: %x\n", hr); IUnknown_Release(unk); hr = IUnknown_QueryInterface(avimux, &IID_ISpecifyPropertyPages, (void**)&unk); ok(hr == S_OK, "QueryInterface(IID_ISpecifyPropertyPages) failed: %x\n", hr); IUnknown_Release(unk); IUnknown_Release(avimux); }
static HRESULT STDMETHODCALLTYPE dxgi_device_CreateSurface(IWineDXGIDevice *iface, const DXGI_SURFACE_DESC *desc, UINT surface_count, DXGI_USAGE usage, const DXGI_SHARED_RESOURCE *shared_resource, IDXGISurface **surface) { struct wined3d_device_parent *device_parent; IWineDXGIDeviceParent *dxgi_device_parent; HRESULT hr; UINT i; UINT j; TRACE("iface %p, desc %p, surface_count %u, usage %#x, shared_resource %p, surface %p\n", iface, desc, surface_count, usage, shared_resource, surface); hr = IWineDXGIDevice_QueryInterface(iface, &IID_IWineDXGIDeviceParent, (void **)&dxgi_device_parent); if (FAILED(hr)) { ERR("Device should implement IWineD3DDeviceParent\n"); return E_FAIL; } device_parent = IWineDXGIDeviceParent_get_wined3d_device_parent(dxgi_device_parent); FIXME("Implement DXGI<->wined3d usage conversion\n"); memset(surface, 0, surface_count * sizeof(*surface)); for (i = 0; i < surface_count; ++i) { struct wined3d_surface *wined3d_surface; IUnknown *parent; hr = device_parent->ops->create_swapchain_surface(device_parent, NULL, desc->Width, desc->Height, wined3dformat_from_dxgi_format(desc->Format), usage, desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE, desc->SampleDesc.Quality, &wined3d_surface); if (FAILED(hr)) { ERR("CreateSurface failed, returning %#x\n", hr); goto fail; } parent = wined3d_surface_get_parent(wined3d_surface); hr = IUnknown_QueryInterface(parent, &IID_IDXGISurface, (void **)&surface[i]); wined3d_surface_decref(wined3d_surface); if (FAILED(hr)) { ERR("Surface should implement IDXGISurface\n"); goto fail; } TRACE("Created IDXGISurface %p (%u/%u)\n", surface[i], i + 1, surface_count); } IWineDXGIDeviceParent_Release(dxgi_device_parent); return S_OK; fail: for (j = 0; j < i; ++j) { IDXGISurface_Release(surface[i]); } IWineDXGIDeviceParent_Release(dxgi_device_parent); return hr; }
/* IDirectMusicSysExTrack IDirectMusicTrack8 part: */ static HRESULT WINAPI IDirectMusicSysExTrack_IDirectMusicTrack_QueryInterface (LPDIRECTMUSICTRACK8 iface, REFIID riid, LPVOID *ppobj) { ICOM_THIS_MULTI(IDirectMusicSysExTrack, TrackVtbl, iface); return IUnknown_QueryInterface ((LPUNKNOWN)&This->UnknownVtbl, riid, ppobj); }
/* IDirectMusicSysExTrack IPersistStream part: */ static HRESULT WINAPI IDirectMusicSysExTrack_IPersistStream_QueryInterface (LPPERSISTSTREAM iface, REFIID riid, LPVOID *ppobj) { ICOM_THIS_MULTI(IDirectMusicSysExTrack, PersistStreamVtbl, iface); return IUnknown_QueryInterface ((LPUNKNOWN)&This->UnknownVtbl, riid, ppobj); }
static HRESULT WINAPI TargetFrame2_QueryInterface(ITargetFrame2 *iface, REFIID riid, void **ppv) { HlinkFrame *This = impl_from_ITargetFrame2(iface); return IUnknown_QueryInterface(This->outer, riid, ppv); }
static HRESULT WINAPI WebBrowserPriv2IE9_QueryInterface(IWebBrowserPriv2IE9 *iface, REFIID riid, void **ppv) { HlinkFrame *This = impl_from_IWebBrowserPriv2IE9(iface); return IUnknown_QueryInterface(This->outer, riid, ppv); }
static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller) { DispatchEx *This = impl_from_IDispatchEx(iface); IUnknown *unk; ITypeInfo *ti; dispex_data_t *data; UINT argerr=0; int min, max, n; HRESULT hres; TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); if(is_custom_dispid(id) && This->data->vtbl && This->data->vtbl->invoke) return This->data->vtbl->invoke(This->outer, id, lcid, wFlags, pdp, pvarRes, pei); if(wFlags == DISPATCH_CONSTRUCT) { FIXME("DISPATCH_CONSTRUCT not implemented\n"); return E_NOTIMPL; } if(is_dynamic_dispid(id)) { DWORD idx = id - DISPID_DYNPROP_0; VARIANT *var; if(!This->dynamic_data || This->dynamic_data->prop_cnt <= idx) return DISP_E_UNKNOWNNAME; var = &This->dynamic_data->props[idx].var; switch(wFlags) { case INVOKE_PROPERTYGET: return VariantCopy(pvarRes, var); case INVOKE_PROPERTYPUT: VariantClear(var); return VariantCopy(var, pdp->rgvarg); default: FIXME("unhandled wFlags %x\n", wFlags); return E_NOTIMPL; } } data = get_dispex_data(This); if(!data) return E_FAIL; min = 0; max = data->func_cnt-1; while(min <= max) { n = (min+max)/2; if(data->funcs[n].id == id) break; if(data->funcs[n].id < id) min = n+1; else max = n-1; } if(min > max) { WARN("invalid id %x\n", id); return DISP_E_UNKNOWNNAME; } hres = get_typeinfo(data->funcs[n].tid, &ti); if(FAILED(hres)) { ERR("Could not get type info: %08x\n", hres); return hres; } hres = IUnknown_QueryInterface(This->outer, tid_ids[data->funcs[n].tid], (void**)&unk); if(FAILED(hres)) { ERR("Could not get iface: %08x\n", hres); return E_FAIL; } hres = ITypeInfo_Invoke(ti, unk, id, wFlags, pdp, pvarRes, pei, &argerr); ITypeInfo_Release(ti); IUnknown_Release(unk); return hres; }
static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv) { DispatchEx *This = impl_from_IDispatchEx(iface); return IUnknown_QueryInterface(This->outer, riid, ppv); }
static HRESULT TransformFilter_Init(const IBaseFilterVtbl *pVtbl, const CLSID* pClsid, const TransformFilterFuncTable* pFuncsTable, TransformFilter* pTransformFilter) { HRESULT hr; PIN_INFO piInput; PIN_INFO piOutput; BaseFilter_Init(&pTransformFilter->filter, pVtbl, pClsid, (DWORD_PTR)(__FILE__ ": TransformFilter.csFilter"), &tfBaseFuncTable); InitializeCriticalSection(&pTransformFilter->csReceive); pTransformFilter->csReceive.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__": TransformFilter.csReceive"); /* pTransformFilter is already allocated */ pTransformFilter->pFuncsTable = pFuncsTable; ZeroMemory(&pTransformFilter->pmt, sizeof(pTransformFilter->pmt)); pTransformFilter->npins = 2; pTransformFilter->ppPins = CoTaskMemAlloc(2 * sizeof(IPin *)); /* construct input pin */ piInput.dir = PINDIR_INPUT; piInput.pFilter = &pTransformFilter->filter.IBaseFilter_iface; lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0])); piOutput.dir = PINDIR_OUTPUT; piOutput.pFilter = &pTransformFilter->filter.IBaseFilter_iface; lstrcpynW(piOutput.achName, wcsOutputPinName, sizeof(piOutput.achName) / sizeof(piOutput.achName[0])); hr = BaseInputPin_Construct(&TransformFilter_InputPin_Vtbl, &piInput, &tf_input_BaseFuncTable, &tf_input_BaseInputFuncTable, &pTransformFilter->filter.csFilter, NULL, &pTransformFilter->ppPins[0]); if (SUCCEEDED(hr)) { hr = BaseOutputPin_Construct(&TransformFilter_OutputPin_Vtbl, sizeof(BaseOutputPin), &piOutput, &tf_output_BaseFuncTable, &tf_output_BaseOutputFuncTable, &pTransformFilter->filter.csFilter, &pTransformFilter->ppPins[1]); if (FAILED(hr)) ERR("Cannot create output pin (%x)\n", hr); else { QualityControlImpl_Create( pTransformFilter->ppPins[0], &pTransformFilter->filter.IBaseFilter_iface, &pTransformFilter->qcimpl); pTransformFilter->qcimpl->IQualityControl_iface.lpVtbl = &TransformFilter_QualityControl_Vtbl; } } if (SUCCEEDED(hr)) { ISeekingPassThru *passthru; pTransformFilter->seekthru_unk = NULL; hr = CoCreateInstance(&CLSID_SeekingPassThru, (IUnknown*)pTransformFilter, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&pTransformFilter->seekthru_unk); if (SUCCEEDED(hr)) { IUnknown_QueryInterface(pTransformFilter->seekthru_unk, &IID_ISeekingPassThru, (void**)&passthru); ISeekingPassThru_Init(passthru, FALSE, pTransformFilter->ppPins[0]); ISeekingPassThru_Release(passthru); } } if (FAILED(hr)) { CoTaskMemFree(pTransformFilter->ppPins); BaseFilterImpl_Release(&pTransformFilter->filter.IBaseFilter_iface); } return hr; }
static HRESULT WINAPI fnCaptureGraphBuilder2_FindPin(ICaptureGraphBuilder2 * iface, IUnknown *pSource, PIN_DIRECTION pindir, const GUID *pCategory, const GUID *pType, BOOL fUnconnected, INT num, IPin **ppPin) { HRESULT hr; IEnumPins *enumpins = NULL; IPin *pin; CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface); TRACE("(%p/%p)->(%p, %x, %s, %s, %d, %i, %p)\n", This, iface, pSource, pindir, debugstr_guid(pCategory), debugstr_guid(pType), fUnconnected, num, ppPin); pin = NULL; hr = IUnknown_QueryInterface(pSource, &IID_IPin, (void**)&pin); if (hr == E_NOINTERFACE) { IBaseFilter *filter = NULL; int numcurrent = 0; hr = IUnknown_QueryInterface(pSource, &IID_IBaseFilter, (void**)&filter); if (hr == E_NOINTERFACE) { WARN("Input not filter or pin?!\n"); return E_FAIL; } hr = IBaseFilter_EnumPins(filter, &enumpins); if (FAILED(hr)) { WARN("Could not enumerate\n"); return hr; } IEnumPins_Reset(enumpins); while (1) { hr = IEnumPins_Next(enumpins, 1, &pin, NULL); if (hr == VFW_E_ENUM_OUT_OF_SYNC) { numcurrent = 0; IEnumPins_Reset(enumpins); pin = NULL; continue; } if (hr != S_OK) break; TRACE("Testing match\n"); if (pin_matches(pin, pindir, pCategory, pType, fUnconnected) && numcurrent++ == num) break; IPin_Release(pin); pin = NULL; } IEnumPins_Release(enumpins); if (hr != S_OK) { WARN("Could not find %s pin # %d\n", (pindir == PINDIR_OUTPUT ? "output" : "input"), numcurrent); return E_FAIL; } } else if (!pin_matches(pin, pindir, pCategory, pType, fUnconnected)) { IPin_Release(pin); return E_FAIL; } *ppPin = pin; return S_OK; }
static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream *iface, REFIID riid, void **ret_iface) { IAVIFileImpl *This = impl_from_IAVIStream(iface); return IUnknown_QueryInterface(This->outer_unk, riid, ret_iface); }
HRESULT d2d_wic_render_target_init(struct d2d_wic_render_target *render_target, ID2D1Factory1 *factory, ID3D10Device1 *d3d_device, IWICBitmap *bitmap, const D2D1_RENDER_TARGET_PROPERTIES *desc) { D3D10_TEXTURE2D_DESC texture_desc; ID3D10Texture2D *texture; IDXGIDevice *dxgi_device; ID2D1Device *device; HRESULT hr; render_target->IUnknown_iface.lpVtbl = &d2d_wic_render_target_vtbl; if (FAILED(hr = IWICBitmap_GetSize(bitmap, &render_target->width, &render_target->height))) { WARN("Failed to get bitmap dimensions, hr %#x.\n", hr); return hr; } texture_desc.Width = render_target->width; texture_desc.Height = render_target->height; texture_desc.MipLevels = 1; texture_desc.ArraySize = 1; texture_desc.Format = desc->pixelFormat.format; if (texture_desc.Format == DXGI_FORMAT_UNKNOWN) { WICPixelFormatGUID bitmap_format; if (FAILED(hr = IWICBitmap_GetPixelFormat(bitmap, &bitmap_format))) { WARN("Failed to get bitmap format, hr %#x.\n", hr); return hr; } if (IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppPBGRA) || IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppBGR)) { texture_desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; } else { WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&bitmap_format)); return D2DERR_UNSUPPORTED_PIXEL_FORMAT; } } switch (texture_desc.Format) { case DXGI_FORMAT_B8G8R8A8_UNORM: render_target->bpp = 4; break; default: FIXME("Unhandled format %#x.\n", texture_desc.Format); return D2DERR_UNSUPPORTED_PIXEL_FORMAT; } texture_desc.SampleDesc.Count = 1; texture_desc.SampleDesc.Quality = 0; texture_desc.Usage = D3D10_USAGE_DEFAULT; texture_desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE; texture_desc.CPUAccessFlags = 0; texture_desc.MiscFlags = desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE ? D3D10_RESOURCE_MISC_GDI_COMPATIBLE : 0; if (FAILED(hr = ID3D10Device1_CreateTexture2D(d3d_device, &texture_desc, NULL, &texture))) { WARN("Failed to create texture, hr %#x.\n", hr); return hr; } hr = ID3D10Texture2D_QueryInterface(texture, &IID_IDXGISurface, (void **)&render_target->dxgi_surface); ID3D10Texture2D_Release(texture); if (FAILED(hr)) { WARN("Failed to get DXGI surface interface, hr %#x.\n", hr); return hr; } texture_desc.Usage = D3D10_USAGE_STAGING; texture_desc.BindFlags = 0; texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ; texture_desc.MiscFlags = 0; if (FAILED(hr = ID3D10Device1_CreateTexture2D(d3d_device, &texture_desc, NULL, &render_target->readback_texture))) { WARN("Failed to create readback texture, hr %#x.\n", hr); IDXGISurface_Release(render_target->dxgi_surface); return hr; } if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device))) { WARN("Failed to get DXGI device, hr %#x.\n", hr); IDXGISurface_Release(render_target->dxgi_surface); return hr; } hr = ID2D1Factory1_CreateDevice(factory, dxgi_device, &device); IDXGIDevice_Release(dxgi_device); if (FAILED(hr)) { WARN("Failed to create D2D device, hr %#x.\n", hr); IDXGISurface_Release(render_target->dxgi_surface); return hr; } hr = d2d_d3d_create_render_target(device, render_target->dxgi_surface, &render_target->IUnknown_iface, &d2d_wic_render_target_ops, desc, (void **)&render_target->dxgi_inner); ID2D1Device_Release(device); if (FAILED(hr)) { WARN("Failed to create DXGI surface render target, hr %#x.\n", hr); ID3D10Texture2D_Release(render_target->readback_texture); IDXGISurface_Release(render_target->dxgi_surface); return hr; } if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner, &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target))) { WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#x.\n", hr); IUnknown_Release(render_target->dxgi_inner); ID3D10Texture2D_Release(render_target->readback_texture); IDXGISurface_Release(render_target->dxgi_surface); return hr; } render_target->bitmap = bitmap; IWICBitmap_AddRef(bitmap); return S_OK; }
static HRESULT WINAPI VideoRenderer_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv) { VideoRendererImpl *This = impl_from_IBaseFilter(iface); return IUnknown_QueryInterface(This->outer_unk, riid, ppv); }
static HRESULT WINAPI AMFilterMiscFlags_QueryInterface(IAMFilterMiscFlags *iface, REFIID riid, void **ppv) { VideoRendererImpl *This = impl_from_IAMFilterMiscFlags(iface); return IUnknown_QueryInterface(This->outer_unk, riid, ppv); }
/****************************************************************************** * IAutoComplete2_fnInit */ static HRESULT WINAPI IAutoComplete2_fnInit( IAutoComplete2 * iface, HWND hwndEdit, IUnknown *punkACL, LPCOLESTR pwzsRegKeyPath, LPCOLESTR pwszQuickComplete) { IAutoCompleteImpl *This = (IAutoCompleteImpl *)iface; TRACE("(%p)->(%p, %p, %s, %s)\n", This, hwndEdit, punkACL, debugstr_w(pwzsRegKeyPath), debugstr_w(pwszQuickComplete)); if (This->options & ACO_SEARCH) FIXME(" ACO_SEARCH not supported\n"); if (This->options & ACO_FILTERPREFIXES) FIXME(" ACO_FILTERPREFIXES not supported\n"); if (This->options & ACO_USETAB) FIXME(" ACO_USETAB not supported\n"); if (This->options & ACO_RTLREADING) FIXME(" ACO_RTLREADING not supported\n"); if (!hwndEdit || !punkACL) return E_INVALIDARG; if (This->initialized) { WARN("Autocompletion object is already initialized\n"); /* This->hwndEdit is set to NULL when the edit window is destroyed. */ return This->hwndEdit ? E_FAIL : E_UNEXPECTED; } if (FAILED (IUnknown_QueryInterface (punkACL, &IID_IEnumString, (LPVOID*)&This->enumstr))) { WARN("No IEnumString interface\n"); return E_NOINTERFACE; } This->initialized = TRUE; This->hwndEdit = hwndEdit; This->wpOrigEditProc = (WNDPROC) SetWindowLongPtrW( hwndEdit, GWLP_WNDPROC, (LONG_PTR) ACEditSubclassProc); /* Keep at least one reference to the object until the edit window is destroyed. */ IAutoComplete2_AddRef((IAutoComplete2 *)This); SetPropW( hwndEdit, autocomplete_propertyW, This ); if (This->options & ACO_AUTOSUGGEST) create_listbox(This); if (pwzsRegKeyPath) { WCHAR *key; WCHAR result[MAX_PATH]; WCHAR *value; HKEY hKey = 0; LONG res; LONG len; /* pwszRegKeyPath contains the key as well as the value, so we split */ key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwzsRegKeyPath)+1)*sizeof(WCHAR)); strcpyW(key, pwzsRegKeyPath); value = strrchrW(key, '\\'); *value = 0; value++; /* Now value contains the value and buffer the key */ res = RegOpenKeyExW(HKEY_CURRENT_USER, key, 0, KEY_READ, &hKey); if (res != ERROR_SUCCESS) { /* if the key is not found, MSDN states we must seek in HKEY_LOCAL_MACHINE */ res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, key, 0, KEY_READ, &hKey); } if (res == ERROR_SUCCESS) { res = RegQueryValueW(hKey, value, result, &len); if (res == ERROR_SUCCESS) { This->quickComplete = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR)); strcpyW(This->quickComplete, result); } RegCloseKey(hKey); } HeapFree(GetProcessHeap(), 0, key); } if ((pwszQuickComplete) && (!This->quickComplete)) { This->quickComplete = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwszQuickComplete)+1)*sizeof(WCHAR)); lstrcpyW(This->quickComplete, pwszQuickComplete); } return S_OK; }