/************************************************************************** * IStream_fnQueryInterface */ static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj) { IUMCacheStream *This = (IUMCacheStream *)iface; TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj); *ppvObj = NULL; if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IStream)) { *ppvObj = This; } if(*ppvObj) { IStream_AddRef((IStream*)*ppvObj); TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj); return S_OK; } TRACE("-- Interface: E_NOINTERFACE\n"); return E_NOINTERFACE; }
static HRESULT WINAPI IWICStreamImpl_InitializeFromIStreamRegion(IWICStream *iface, IStream *pIStream, ULARGE_INTEGER ulOffset, ULARGE_INTEGER ulMaxSize) { IWICStreamImpl *This = impl_from_IWICStream(iface); StreamOnStreamRange *pObject; TRACE("(%p,%p)\n", iface, pIStream); if (!pIStream) return E_INVALIDARG; if (This->pStream) return WINCODEC_ERR_WRONGSTATE; pObject = HeapAlloc(GetProcessHeap(), 0, sizeof(StreamOnStreamRange)); if (!pObject) return E_OUTOFMEMORY; pObject->IStream_iface.lpVtbl = &StreamOnStreamRange_Vtbl; pObject->ref = 1; IStream_AddRef(pIStream); pObject->stream = pIStream; pObject->pos.QuadPart = 0; pObject->offset = ulOffset; pObject->max_size = ulMaxSize; InitializeCriticalSection(&pObject->lock); pObject->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": StreamOnStreamRange.lock"); if (InterlockedCompareExchangePointer((void**)&This->pStream, pObject, NULL)) { /* Some other thread set the stream first. */ IStream_Release(&pObject->IStream_iface); return WINCODEC_ERR_WRONGSTATE; } return S_OK; }
static HRESULT WINAPI IcnsEncoder_Initialize(IWICBitmapEncoder *iface, IStream *pIStream, WICBitmapEncoderCacheOption cacheOption) { IcnsEncoder *This = impl_from_IWICBitmapEncoder(iface); HRESULT hr = S_OK; TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption); EnterCriticalSection(&This->lock); if (This->icns_family) { hr = WINCODEC_ERR_WRONGSTATE; goto end; } This->icns_family = (IconFamilyHandle)NewHandle(0); if (!This->icns_family) { WARN("error creating icns family\n"); hr = E_FAIL; goto end; } IStream_AddRef(pIStream); This->stream = pIStream; end: LeaveCriticalSection(&This->lock); return hr; }
static HRESULT WINAPI ProtocolStream_QueryInterface(IStream *iface, REFIID riid, void **ppv) { ProtocolStream *This = STREAM_THIS(iface); *ppv = NULL; if(IsEqualGUID(&IID_IUnknown, riid)) { TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); *ppv = STREAM(This); } else if(IsEqualGUID(&IID_ISequentialStream, riid)) { TRACE("(%p)->(IID_ISequentialStream %p)\n", This, ppv); *ppv = STREAM(This); } else if(IsEqualGUID(&IID_IStream, riid)) { TRACE("(%p)->(IID_IStream %p)\n", This, ppv); *ppv = STREAM(This); } if(*ppv) { IStream_AddRef(STREAM(This)); return S_OK; } WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); return E_NOINTERFACE; }
/*** * This implements the IUnknown method QueryInterface for this * class */ static HRESULT WINAPI StgStreamImpl_QueryInterface( IStream* iface, REFIID riid, /* [in] */ void** ppvObject) /* [iid_is][out] */ { StgStreamImpl* This = impl_from_IStream(iface); if (ppvObject==0) return E_INVALIDARG; *ppvObject = 0; if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_ISequentialStream, riid) || IsEqualIID(&IID_IStream, riid)) { *ppvObject = &This->IStream_iface; } else return E_NOINTERFACE; IStream_AddRef(iface); return S_OK; }
static HRESULT stgmed_stream_get_result(stgmed_obj_t *obj, DWORD bindf, void **result) { ProtocolStream *stream = (ProtocolStream*)obj; IStream_AddRef(STREAM(stream)); *result = STREAM(stream); return S_OK; }
static HRESULT WINAPI PngEncoder_Initialize(IWICBitmapEncoder *iface, IStream *pIStream, WICBitmapEncoderCacheOption cacheOption) { PngEncoder *This = impl_from_IWICBitmapEncoder(iface); jmp_buf jmpbuf; TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption); EnterCriticalSection(&This->lock); if (This->png_ptr) { LeaveCriticalSection(&This->lock); return WINCODEC_ERR_WRONGSTATE; } /* initialize libpng */ This->png_ptr = ppng_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (!This->png_ptr) { LeaveCriticalSection(&This->lock); return E_FAIL; } This->info_ptr = ppng_create_info_struct(This->png_ptr); if (!This->info_ptr) { ppng_destroy_write_struct(&This->png_ptr, NULL); This->png_ptr = NULL; LeaveCriticalSection(&This->lock); return E_FAIL; } IStream_AddRef(pIStream); This->stream = pIStream; /* set up setjmp/longjmp error handling */ if (setjmp(jmpbuf)) { ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr); This->png_ptr = NULL; IStream_Release(This->stream); This->stream = NULL; LeaveCriticalSection(&This->lock); return E_FAIL; } ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn); /* set up custom i/o handling */ ppng_set_write_fn(This->png_ptr, This, user_write_data, user_flush); LeaveCriticalSection(&This->lock); return S_OK; }
static HRESULT WINAPI BmpEncoder_Initialize(IWICBitmapEncoder *iface, IStream *pIStream, WICBitmapEncoderCacheOption cacheOption) { BmpEncoder *This = impl_from_IWICBitmapEncoder(iface); TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption); IStream_AddRef(pIStream); This->stream = pIStream; return S_OK; }
/*********************************************************************** * CopyStgMedium (URLMON.@) */ HRESULT WINAPI CopyStgMedium(const STGMEDIUM *src, STGMEDIUM *dst) { TRACE("(%p %p)\n", src, dst); if(!src || !dst) return E_POINTER; *dst = *src; switch(dst->tymed) { case TYMED_NULL: break; case TYMED_FILE: if(src->u.lpszFileName && !src->pUnkForRelease) { DWORD size = (strlenW(src->u.lpszFileName)+1)*sizeof(WCHAR); dst->u.lpszFileName = CoTaskMemAlloc(size); if(!dst->u.lpszFileName) return E_OUTOFMEMORY; memcpy(dst->u.lpszFileName, src->u.lpszFileName, size); } break; case TYMED_ISTREAM: if(dst->u.pstm) IStream_AddRef(dst->u.pstm); break; case TYMED_ISTORAGE: if(dst->u.pstg) IStorage_AddRef(dst->u.pstg); break; case TYMED_HGLOBAL: if(dst->u.hGlobal) { SIZE_T size = GlobalSize(src->u.hGlobal); char *src_ptr, *dst_ptr; dst->u.hGlobal = GlobalAlloc(GMEM_FIXED, size); if(!dst->u.hGlobal) return E_OUTOFMEMORY; dst_ptr = GlobalLock(dst->u.hGlobal); src_ptr = GlobalLock(src->u.hGlobal); memcpy(dst_ptr, src_ptr, size); GlobalUnlock(src_ptr); GlobalUnlock(dst_ptr); } break; default: FIXME("Unimplemented tymed %d\n", src->tymed); } if(dst->pUnkForRelease) IUnknown_AddRef(dst->pUnkForRelease); return S_OK; }
static HRESULT stgmed_stream_get_result(stgmed_obj_t *obj, DWORD bindf, void **result) { ProtocolStream *stream = (ProtocolStream*)obj; if(!(bindf & BINDF_ASYNCHRONOUS) && stream->buf->file == INVALID_HANDLE_VALUE && (stream->buf->hres != S_FALSE || stream->buf->size)) return INET_E_DATA_NOT_AVAILABLE; IStream_AddRef(STREAM(stream)); *result = STREAM(stream); return S_OK; }
static HRESULT WINAPI TestStream_QueryInterface(IStream *iface, REFIID riid, void **ppv) { if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ISequentialStream) || IsEqualIID(riid, &IID_IStream)) { *ppv = iface; IStream_AddRef(iface); return S_OK; } *ppv = NULL; return E_NOINTERFACE; }
static HRESULT WINAPI JpegEncoder_Initialize(IWICBitmapEncoder *iface, IStream *pIStream, WICBitmapEncoderCacheOption cacheOption) { JpegEncoder *This = impl_from_IWICBitmapEncoder(iface); jmp_buf jmpbuf; TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption); EnterCriticalSection(&This->lock); if (This->initialized) { LeaveCriticalSection(&This->lock); return WINCODEC_ERR_WRONGSTATE; } pjpeg_std_error(&This->jerr); This->jerr.error_exit = error_exit_fn; This->jerr.emit_message = emit_message_fn; This->cinfo.err = &This->jerr; This->cinfo.client_data = jmpbuf; if (setjmp(jmpbuf)) { LeaveCriticalSection(&This->lock); return E_FAIL; } pjpeg_CreateCompress(&This->cinfo, JPEG_LIB_VERSION, sizeof(struct jpeg_compress_struct)); This->stream = pIStream; IStream_AddRef(pIStream); This->dest_mgr.next_output_byte = This->dest_buffer; This->dest_mgr.free_in_buffer = sizeof(This->dest_buffer); This->dest_mgr.init_destination = dest_mgr_init_destination; This->dest_mgr.empty_output_buffer = dest_mgr_empty_output_buffer; This->dest_mgr.term_destination = dest_mgr_term_destination; This->cinfo.dest = &This->dest_mgr; This->initialized = TRUE; LeaveCriticalSection(&This->lock); return S_OK; }
static HRESULT WINAPI BmpEncoder_CreateNewFrame(IWICBitmapEncoder *iface, IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions) { BmpEncoder *This = impl_from_IWICBitmapEncoder(iface); BmpFrameEncode *encode; HRESULT hr; static const PROPBAG2 opts[1] = { { PROPBAG2_TYPE_DATA, VT_BOOL, 0, 0, (LPOLESTR)wszEnableV5Header32bppBGRA }, }; TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions); if (This->frame) return WINCODEC_ERR_UNSUPPORTEDOPERATION; if (!This->stream) return WINCODEC_ERR_NOTINITIALIZED; if (ppIEncoderOptions) { hr = CreatePropertyBag2(opts, ARRAY_SIZE(opts), ppIEncoderOptions); if (FAILED(hr)) return hr; } encode = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpFrameEncode)); if (!encode) { IPropertyBag2_Release(*ppIEncoderOptions); *ppIEncoderOptions = NULL; return E_OUTOFMEMORY; } encode->IWICBitmapFrameEncode_iface.lpVtbl = &BmpFrameEncode_Vtbl; encode->ref = 2; IStream_AddRef(This->stream); encode->stream = This->stream; encode->initialized = FALSE; encode->width = 0; encode->height = 0; encode->bits = NULL; encode->format = NULL; encode->xres = 0.0; encode->yres = 0.0; encode->lineswritten = 0; encode->colors = 0; encode->committed = FALSE; *ppIFrameEncode = &encode->IWICBitmapFrameEncode_iface; This->frame = encode; return S_OK; }
UINT MSI_RecordCopyField( MSIRECORD *in_rec, UINT in_n, MSIRECORD *out_rec, UINT out_n ) { UINT r = ERROR_SUCCESS; msiobj_lock( &in_rec->hdr ); if ( in_n > in_rec->count || out_n > out_rec->count ) r = ERROR_FUNCTION_FAILED; else if ( in_rec != out_rec || in_n != out_n ) { LPWSTR str; MSIFIELD *in, *out; in = &in_rec->fields[in_n]; out = &out_rec->fields[out_n]; switch ( in->type ) { case MSIFIELD_NULL: break; case MSIFIELD_INT: out->u.iVal = in->u.iVal; break; case MSIFIELD_INTPTR: out->u.pVal = in->u.pVal; break; case MSIFIELD_WSTR: if ((str = msi_strdupW( in->u.szwVal, in->len ))) { out->u.szwVal = str; out->len = in->len; } else r = ERROR_OUTOFMEMORY; break; case MSIFIELD_STREAM: IStream_AddRef( in->u.stream ); out->u.stream = in->u.stream; break; default: ERR("invalid field type %d\n", in->type); } if (r == ERROR_SUCCESS) out->type = in->type; } msiobj_unlock( &in_rec->hdr ); return r; }
UINT MSI_RecordSetIStream( MSIRECORD *rec, UINT iField, IStream *stm ) { TRACE("%p %d %p\n", rec, iField, stm); if( iField > rec->count ) return ERROR_INVALID_FIELD; MSI_FreeField( &rec->fields[iField] ); rec->fields[iField].type = MSIFIELD_STREAM; rec->fields[iField].u.stream = stm; IStream_AddRef( stm ); return ERROR_SUCCESS; }
UINT MSI_RecordGetIStream( MSIRECORD *rec, UINT iField, IStream **pstm) { TRACE("%p %d %p\n", rec, iField, pstm); if( iField > rec->count ) return ERROR_INVALID_FIELD; if( rec->fields[iField].type != MSIFIELD_STREAM ) return ERROR_INVALID_FIELD; *pstm = rec->fields[iField].u.stream; IStream_AddRef( *pstm ); return ERROR_SUCCESS; }
HRESULT STDMETHODCALLTYPE CliprdrStream_QueryInterface(IStream* This, REFIID riid, void** ppvObject) { CliprdrStream* instance = (CliprdrStream*) This; if (IsEqualIID(riid, &IID_IStream) || IsEqualIID(riid, &IID_IUnknown)) { IStream_AddRef(This); *ppvObject = This; return S_OK; } else { *ppvObject = 0; return E_NOINTERFACE; } }
static HRESULT WINAPI Test_IStream_QueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj) { if (ppvObj == NULL) return E_POINTER; if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IStream)) { *ppvObj = iface; IStream_AddRef(iface); return S_OK; } *ppvObj = NULL; return E_NOINTERFACE; }
/************************************************************************** * IStream_fnQueryInterface */ static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj) { ISHFileStream *This = impl_from_IStream(iface); TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppvObj); *ppvObj = NULL; if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IStream)) { IStream_AddRef(iface); *ppvObj = iface; return S_OK; } return E_NOINTERFACE; }
/*** * This implements the IUnknown method QueryInterface for this * class */ static HRESULT WINAPI StgStreamImpl_QueryInterface( IStream* iface, REFIID riid, /* [in] */ void** ppvObject) /* [iid_is][out] */ { StgStreamImpl* const This=(StgStreamImpl*)iface; /* * Perform a sanity check on the parameters. */ if (ppvObject==0) return E_INVALIDARG; /* * Initialize the return parameter. */ *ppvObject = 0; /* * Compare the riid with the interface IDs implemented by this object. */ if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPersist, riid) || IsEqualIID(&IID_IPersistStream, riid) || IsEqualIID(&IID_ISequentialStream, riid) || IsEqualIID(&IID_IStream, riid)) { *ppvObject = This; } /* * Check that we obtained an interface. */ if ((*ppvObject)==0) return E_NOINTERFACE; /* * Query Interface always increases the reference count by one when it is * successful */ IStream_AddRef(iface); return S_OK; }
static HRESULT WINAPI ITSS_IStream_QueryInterface( IStream* iface, REFIID riid, void** ppvObject) { IStream_Impl *This = impl_from_IStream(iface); if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISequentialStream) || IsEqualGUID(riid, &IID_IStream)) { IStream_AddRef(iface); *ppvObject = This; return S_OK; } WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject); return E_NOINTERFACE; }
/* * @implemented */ HRESULT NTAPI RtlQueryInterfaceMemoryStream( _In_ IStream *This, _In_ REFIID RequestedIid, _Outptr_ PVOID *ResultObject) { if (IsEqualGUID(RequestedIid, &IID_IUnknown) || IsEqualGUID(RequestedIid, &IID_ISequentialStream) || IsEqualGUID(RequestedIid, &IID_IStream)) { IStream_AddRef(This); *ResultObject = This; return S_OK; } *ResultObject = NULL; return E_NOINTERFACE; }
static HRESULT WINAPI BmpEncoder_CreateNewFrame(IWICBitmapEncoder *iface, IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions) { BmpEncoder *This = impl_from_IWICBitmapEncoder(iface); BmpFrameEncode *encode; HRESULT hr; TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions); if (This->frame) return WINCODEC_ERR_UNSUPPORTEDOPERATION; if (!This->stream) return WINCODEC_ERR_NOTINITIALIZED; hr = CreatePropertyBag2(NULL, 0, ppIEncoderOptions); if (FAILED(hr)) return hr; encode = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpFrameEncode)); if (!encode) { IPropertyBag2_Release(*ppIEncoderOptions); *ppIEncoderOptions = NULL; return E_OUTOFMEMORY; } encode->IWICBitmapFrameEncode_iface.lpVtbl = &BmpFrameEncode_Vtbl; encode->ref = 2; IStream_AddRef(This->stream); encode->stream = This->stream; encode->initialized = FALSE; encode->width = 0; encode->height = 0; encode->bits = NULL; encode->format = NULL; encode->xres = 0.0; encode->yres = 0.0; encode->lineswritten = 0; encode->committed = FALSE; *ppIFrameEncode = &encode->IWICBitmapFrameEncode_iface; This->frame = encode; return S_OK; }
GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile) { GpStatus stat; TRACE("(%p %p %d %p %d %p %p)\n", stream, hdc, type, frameRect, frameUnit, desc, metafile); if (!stream) return InvalidParameter; stat = GdipRecordMetafile(hdc, type, frameRect, frameUnit, desc, metafile); if (stat == Ok) { (*metafile)->record_stream = stream; IStream_AddRef(stream); } return stat; }
static inline HRESULT XMLView_Moniker_Create(IMoniker *mon, IStream *stream, IMoniker **ret) { Moniker *wrap; wrap = heap_alloc_zero(sizeof(Moniker)); if(!wrap) return E_OUTOFMEMORY; wrap->IMoniker_iface.lpVtbl = &XMLView_MonikerVtbl; wrap->ref = 1; wrap->mon = mon; IMoniker_AddRef(mon); wrap->stream = stream; IStream_AddRef(stream); *ret = &wrap->IMoniker_iface; return S_OK; }
static ULONG send_http_request(HttpProtocol *This) { INTERNET_BUFFERSW send_buffer = {sizeof(INTERNET_BUFFERSW)}; BOOL res; send_buffer.lpcszHeader = This->full_header; send_buffer.dwHeadersLength = send_buffer.dwHeadersTotal = strlenW(This->full_header); if(This->base.bind_info.dwBindVerb != BINDVERB_GET) { switch(This->base.bind_info.stgmedData.tymed) { case TYMED_HGLOBAL: /* Native does not use GlobalLock/GlobalUnlock, so we won't either */ send_buffer.lpvBuffer = This->base.bind_info.stgmedData.u.hGlobal; send_buffer.dwBufferLength = send_buffer.dwBufferTotal = This->base.bind_info.cbstgmedData; break; case TYMED_ISTREAM: { LARGE_INTEGER offset; send_buffer.dwBufferTotal = This->base.bind_info.cbstgmedData; if(!This->base.post_stream) { This->base.post_stream = This->base.bind_info.stgmedData.u.pstm; IStream_AddRef(This->base.post_stream); } offset.QuadPart = 0; IStream_Seek(This->base.post_stream, offset, STREAM_SEEK_SET, NULL); break; } default: FIXME("Unsupported This->base.bind_info.stgmedData.tymed %d\n", This->base.bind_info.stgmedData.tymed); } } if(This->base.post_stream) res = HttpSendRequestExW(This->base.request, &send_buffer, NULL, 0, 0); else res = HttpSendRequestW(This->base.request, send_buffer.lpcszHeader, send_buffer.dwHeadersLength, send_buffer.lpvBuffer, send_buffer.dwBufferLength); return res ? 0 : GetLastError(); }
/************************************************************************** * IStream_fnQueryInterface */ static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj) { ISHRegStream *This = impl_from_IStream(iface); TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj); *ppvObj = NULL; if(IsEqualIID(riid, &IID_IUnknown)) /*IUnknown*/ *ppvObj = This; else if(IsEqualIID(riid, &IID_IStream)) /*IStream*/ *ppvObj = This; if(*ppvObj) { IStream_AddRef((IStream*)*ppvObj); TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj); return S_OK; } TRACE("-- Interface: E_NOINTERFACE\n"); return E_NOINTERFACE; }
static inline HRESULT XMLView_BindStatusCallback_Create(IBindStatusCallback *bsc_html, IMoniker *mon, IStream *stream, IBindStatusCallback **ret) { BindStatusCallback *bsc; bsc = heap_alloc_zero(sizeof(BindStatusCallback)); if(!bsc) return E_OUTOFMEMORY; bsc->IBindStatusCallback_iface.lpVtbl = &XMLView_BindStatusCallbackVtbl; bsc->ref = 1; bsc->bsc = bsc_html; IBindStatusCallback_AddRef(bsc_html); bsc->stream = stream; IStream_AddRef(bsc->stream); bsc->mon = mon; IMoniker_AddRef(mon); *ret = &bsc->IBindStatusCallback_iface; return S_OK; }
/*** * This method is part of the IStream interface. * * This method returns a clone of the interface that allows for * another seek pointer * * See the documentation of IStream for more info. * * I am not totally sure what I am doing here but I presume that this * should be basically as simple as creating a new stream with the same * parent etc and positioning its seek cursor. */ static HRESULT WINAPI StgStreamImpl_Clone( IStream* iface, IStream** ppstm) /* [out] */ { StgStreamImpl* This = impl_from_IStream(iface); HRESULT hres; StgStreamImpl* new_stream; LARGE_INTEGER seek_pos; TRACE("%p %p\n", This, ppstm); /* * Sanity check */ if (!This->parentStorage) return STG_E_REVERTED; if ( ppstm == 0 ) return STG_E_INVALIDPOINTER; new_stream = StgStreamImpl_Construct (This->parentStorage, This->grfMode, This->dirEntry); if (!new_stream) return STG_E_INSUFFICIENTMEMORY; /* Currently the only reason for new_stream=0 */ *ppstm = &new_stream->IStream_iface; IStream_AddRef(*ppstm); seek_pos.QuadPart = This->currentPosition.QuadPart; hres = IStream_Seek(*ppstm, seek_pos, STREAM_SEEK_SET, NULL); assert (SUCCEEDED(hres)); return S_OK; }
/*********************************************************************** * CopyStgMedium (URLMON.@) */ HRESULT WINAPI CopyStgMedium(const STGMEDIUM *src, STGMEDIUM *dst) { TRACE("(%p %p)\n", src, dst); if(!src || !dst) return E_POINTER; *dst = *src; switch(dst->tymed) { case TYMED_NULL: break; case TYMED_FILE: if(src->u.lpszFileName && !src->pUnkForRelease) { DWORD size = (strlenW(src->u.lpszFileName)+1)*sizeof(WCHAR); dst->u.lpszFileName = CoTaskMemAlloc(size); memcpy(dst->u.lpszFileName, src->u.lpszFileName, size); } break; case TYMED_ISTREAM: if(dst->u.pstm) IStream_AddRef(dst->u.pstm); break; case TYMED_ISTORAGE: if(dst->u.pstg) IStorage_AddRef(dst->u.pstg); break; default: FIXME("Unimplemented tymed %d\n", src->tymed); } if(dst->pUnkForRelease) IUnknown_AddRef(dst->pUnkForRelease); return S_OK; }