* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
-#include "wine/debug.h"
-
-#define COBJMACROS
-#include "windef.h"
-#include "winbase.h"
-#include "winreg.h"
-#include "objbase.h"
-#include "shlwapi.h"
-#include "wincodec.h"
#include "wincodecs_private.h"
-WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
+#include <shlwapi.h>
/******************************************
* StreamOnMemory implementation
*
*/
typedef struct StreamOnMemory {
- const IStreamVtbl *lpVtbl;
+ IStream IStream_iface;
LONG ref;
BYTE *pbMemory;
CRITICAL_SECTION lock; /* must be held when pbMemory or dwCurPos is accessed */
} StreamOnMemory;
+static inline StreamOnMemory *StreamOnMemory_from_IStream(IStream *iface)
+{
+ return CONTAINING_RECORD(iface, StreamOnMemory, IStream_iface);
+}
+
static HRESULT WINAPI StreamOnMemory_QueryInterface(IStream *iface,
REFIID iid, void **ppv)
{
static ULONG WINAPI StreamOnMemory_AddRef(IStream *iface)
{
- StreamOnMemory *This = (StreamOnMemory*)iface;
+ StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
ULONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) refcount=%u\n", iface, ref);
static ULONG WINAPI StreamOnMemory_Release(IStream *iface)
{
- StreamOnMemory *This = (StreamOnMemory*)iface;
+ StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
ULONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) refcount=%u\n", iface, ref);
static HRESULT WINAPI StreamOnMemory_Read(IStream *iface,
void *pv, ULONG cb, ULONG *pcbRead)
{
- StreamOnMemory *This = (StreamOnMemory*)iface;
+ StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
ULONG uBytesRead;
TRACE("(%p)\n", This);
EnterCriticalSection(&This->lock);
uBytesRead = min(cb, This->dwMemsize - This->dwCurPos);
- memcpy(pv, This->pbMemory + This->dwCurPos, uBytesRead);
+ memmove(pv, This->pbMemory + This->dwCurPos, uBytesRead);
This->dwCurPos += uBytesRead;
LeaveCriticalSection(&This->lock);
static HRESULT WINAPI StreamOnMemory_Write(IStream *iface,
void const *pv, ULONG cb, ULONG *pcbWritten)
{
- StreamOnMemory *This = (StreamOnMemory*)iface;
+ StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
HRESULT hr;
TRACE("(%p)\n", This);
hr = STG_E_MEDIUMFULL;
}
else {
- memcpy(This->pbMemory + This->dwCurPos, pv, cb);
+ memmove(This->pbMemory + This->dwCurPos, pv, cb);
This->dwCurPos += cb;
hr = S_OK;
if (pcbWritten) *pcbWritten = cb;
static HRESULT WINAPI StreamOnMemory_Seek(IStream *iface,
LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
{
- StreamOnMemory *This = (StreamOnMemory*)iface;
+ StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
LARGE_INTEGER NewPosition;
HRESULT hr=S_OK;
TRACE("(%p)\n", This);
static HRESULT WINAPI StreamOnMemory_Stat(IStream *iface,
STATSTG *pstatstg, DWORD grfStatFlag)
{
- StreamOnMemory *This = (StreamOnMemory*)iface;
+ StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
TRACE("(%p)\n", This);
if (!pstatstg) return E_INVALIDARG;
}
-const IStreamVtbl StreamOnMemory_Vtbl =
+static const IStreamVtbl StreamOnMemory_Vtbl =
{
/*** IUnknown methods ***/
StreamOnMemory_QueryInterface,
StreamOnMemory_Clone,
};
+/******************************************
+ * StreamOnFileHandle implementation (internal)
+ *
+ */
+typedef struct StreamOnFileHandle {
+ IStream IStream_iface;
+ LONG ref;
+
+ HANDLE map;
+ void *mem;
+ IWICStream *stream;
+} StreamOnFileHandle;
+
+static inline StreamOnFileHandle *StreamOnFileHandle_from_IStream(IStream *iface)
+{
+ return CONTAINING_RECORD(iface, StreamOnFileHandle, IStream_iface);
+}
+
+static HRESULT WINAPI StreamOnFileHandle_QueryInterface(IStream *iface,
+ REFIID iid, void **ppv)
+{
+ TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+ if (!ppv) return E_INVALIDARG;
+
+ if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IStream, iid) ||
+ IsEqualIID(&IID_ISequentialStream, iid))
+ {
+ *ppv = iface;
+ IUnknown_AddRef((IUnknown*)*ppv);
+ return S_OK;
+ }
+ else
+ {
+ *ppv = NULL;
+ return E_NOINTERFACE;
+ }
+}
+
+static ULONG WINAPI StreamOnFileHandle_AddRef(IStream *iface)
+{
+ StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
+ ULONG ref = InterlockedIncrement(&This->ref);
+
+ TRACE("(%p) refcount=%u\n", iface, ref);
+
+ return ref;
+}
+
+static ULONG WINAPI StreamOnFileHandle_Release(IStream *iface)
+{
+ StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
+ ULONG ref = InterlockedDecrement(&This->ref);
+
+ TRACE("(%p) refcount=%u\n", iface, ref);
+
+ if (ref == 0) {
+ IWICStream_Release(This->stream);
+ UnmapViewOfFile(This->mem);
+ CloseHandle(This->map);
+ HeapFree(GetProcessHeap(), 0, This);
+ }
+ return ref;
+}
+
+static HRESULT WINAPI StreamOnFileHandle_Read(IStream *iface,
+ void *pv, ULONG cb, ULONG *pcbRead)
+{
+ StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
+ TRACE("(%p)\n", This);
+
+ return IWICStream_Read(This->stream, pv, cb, pcbRead);
+}
+
+static HRESULT WINAPI StreamOnFileHandle_Write(IStream *iface,
+ void const *pv, ULONG cb, ULONG *pcbWritten)
+{
+ ERR("(%p)\n", iface);
+ return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
+}
+
+static HRESULT WINAPI StreamOnFileHandle_Seek(IStream *iface,
+ LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
+{
+ StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
+ TRACE("(%p)\n", This);
+
+ return IWICStream_Seek(This->stream, dlibMove, dwOrigin, plibNewPosition);
+}
+
+static HRESULT WINAPI StreamOnFileHandle_SetSize(IStream *iface,
+ ULARGE_INTEGER libNewSize)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI StreamOnFileHandle_CopyTo(IStream *iface,
+ IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI StreamOnFileHandle_Commit(IStream *iface,
+ DWORD grfCommitFlags)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI StreamOnFileHandle_Revert(IStream *iface)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI StreamOnFileHandle_LockRegion(IStream *iface,
+ ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI StreamOnFileHandle_UnlockRegion(IStream *iface,
+ ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI StreamOnFileHandle_Stat(IStream *iface,
+ STATSTG *pstatstg, DWORD grfStatFlag)
+{
+ StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
+ TRACE("(%p)\n", This);
+
+ return IWICStream_Stat(This->stream, pstatstg, grfStatFlag);
+}
+
+static HRESULT WINAPI StreamOnFileHandle_Clone(IStream *iface,
+ IStream **ppstm)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+
+static const IStreamVtbl StreamOnFileHandle_Vtbl =
+{
+ /*** IUnknown methods ***/
+ StreamOnFileHandle_QueryInterface,
+ StreamOnFileHandle_AddRef,
+ StreamOnFileHandle_Release,
+ /*** ISequentialStream methods ***/
+ StreamOnFileHandle_Read,
+ StreamOnFileHandle_Write,
+ /*** IStream methods ***/
+ StreamOnFileHandle_Seek,
+ StreamOnFileHandle_SetSize,
+ StreamOnFileHandle_CopyTo,
+ StreamOnFileHandle_Commit,
+ StreamOnFileHandle_Revert,
+ StreamOnFileHandle_LockRegion,
+ StreamOnFileHandle_UnlockRegion,
+ StreamOnFileHandle_Stat,
+ StreamOnFileHandle_Clone,
+};
+
+/******************************************
+ * StreamOnStreamRange implementation
+ *
+ * Used by IWICStream_InitializeFromIStreamRegion
+ *
+ */
+typedef struct StreamOnStreamRange {
+ IStream IStream_iface;
+ LONG ref;
+
+ IStream *stream;
+ ULARGE_INTEGER pos;
+ ULARGE_INTEGER offset;
+ ULARGE_INTEGER max_size;
+
+ CRITICAL_SECTION lock;
+} StreamOnStreamRange;
+
+static inline StreamOnStreamRange *StreamOnStreamRange_from_IStream(IStream *iface)
+{
+ return CONTAINING_RECORD(iface, StreamOnStreamRange, IStream_iface);
+}
+
+static HRESULT WINAPI StreamOnStreamRange_QueryInterface(IStream *iface,
+ REFIID iid, void **ppv)
+{
+ TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+ if (!ppv) return E_INVALIDARG;
+
+ if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IStream, iid) ||
+ IsEqualIID(&IID_ISequentialStream, iid))
+ {
+ *ppv = iface;
+ IUnknown_AddRef((IUnknown*)*ppv);
+ return S_OK;
+ }
+ else
+ {
+ *ppv = NULL;
+ return E_NOINTERFACE;
+ }
+}
+
+static ULONG WINAPI StreamOnStreamRange_AddRef(IStream *iface)
+{
+ StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
+ ULONG ref = InterlockedIncrement(&This->ref);
+
+ TRACE("(%p) refcount=%u\n", iface, ref);
+
+ return ref;
+}
+
+static ULONG WINAPI StreamOnStreamRange_Release(IStream *iface)
+{
+ StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
+ ULONG ref = InterlockedDecrement(&This->ref);
+
+ TRACE("(%p) refcount=%u\n", iface, ref);
+
+ if (ref == 0) {
+ This->lock.DebugInfo->Spare[0] = 0;
+ DeleteCriticalSection(&This->lock);
+ IStream_Release(This->stream);
+ HeapFree(GetProcessHeap(), 0, This);
+ }
+ return ref;
+}
+
+static HRESULT WINAPI StreamOnStreamRange_Read(IStream *iface,
+ void *pv, ULONG cb, ULONG *pcbRead)
+{
+ StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
+ ULONG uBytesRead=0;
+ HRESULT hr;
+ ULARGE_INTEGER OldPosition;
+ LARGE_INTEGER SetPosition;
+ TRACE("(%p)\n", This);
+
+ if (!pv) return E_INVALIDARG;
+
+ EnterCriticalSection(&This->lock);
+ SetPosition.QuadPart = 0;
+ hr = IStream_Seek(This->stream, SetPosition, STREAM_SEEK_CUR, &OldPosition);
+ if (SUCCEEDED(hr))
+ {
+ SetPosition.QuadPart = This->pos.QuadPart + This->offset.QuadPart;
+ hr = IStream_Seek(This->stream, SetPosition, STREAM_SEEK_SET, NULL);
+ }
+ if (SUCCEEDED(hr))
+ {
+ if (This->pos.QuadPart + cb > This->max_size.QuadPart)
+ {
+ /* This would read past the end of the stream. */
+ if (This->pos.QuadPart > This->max_size.QuadPart)
+ cb = 0;
+ else
+ cb = This->max_size.QuadPart - This->pos.QuadPart;
+ }
+ hr = IStream_Read(This->stream, pv, cb, &uBytesRead);
+ SetPosition.QuadPart = OldPosition.QuadPart;
+ IStream_Seek(This->stream, SetPosition, STREAM_SEEK_SET, NULL);
+ }
+ if (SUCCEEDED(hr))
+ This->pos.QuadPart += uBytesRead;
+ LeaveCriticalSection(&This->lock);
+
+ if (SUCCEEDED(hr) && pcbRead) *pcbRead = uBytesRead;
+
+ return hr;
+}
+
+static HRESULT WINAPI StreamOnStreamRange_Write(IStream *iface,
+ void const *pv, ULONG cb, ULONG *pcbWritten)
+{
+ StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
+ HRESULT hr;
+ ULARGE_INTEGER OldPosition;
+ LARGE_INTEGER SetPosition;
+ ULONG uBytesWritten=0;
+ TRACE("(%p)\n", This);
+
+ if (!pv) return E_INVALIDARG;
+
+ EnterCriticalSection(&This->lock);
+ SetPosition.QuadPart = 0;
+ hr = IStream_Seek(This->stream, SetPosition, STREAM_SEEK_CUR, &OldPosition);
+ if (SUCCEEDED(hr))
+ {
+ SetPosition.QuadPart = This->pos.QuadPart + This->offset.QuadPart;
+ hr = IStream_Seek(This->stream, SetPosition, STREAM_SEEK_SET, NULL);
+ }
+ if (SUCCEEDED(hr))
+ {
+ if (This->pos.QuadPart + cb > This->max_size.QuadPart)
+ {
+ /* This would read past the end of the stream. */
+ if (This->pos.QuadPart > This->max_size.QuadPart)
+ cb = 0;
+ else
+ cb = This->max_size.QuadPart - This->pos.QuadPart;
+ }
+ hr = IStream_Write(This->stream, pv, cb, &uBytesWritten);
+ SetPosition.QuadPart = OldPosition.QuadPart;
+ IStream_Seek(This->stream, SetPosition, STREAM_SEEK_SET, NULL);
+ }
+ if (SUCCEEDED(hr))
+ This->pos.QuadPart += uBytesWritten;
+ LeaveCriticalSection(&This->lock);
+
+ if (SUCCEEDED(hr) && pcbWritten) *pcbWritten = uBytesWritten;
+
+ return hr;
+}
+
+static HRESULT WINAPI StreamOnStreamRange_Seek(IStream *iface,
+ LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
+{
+ StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
+ ULARGE_INTEGER NewPosition, actual_size;
+ HRESULT hr=S_OK;
+ STATSTG statstg;
+ TRACE("(%p)\n", This);
+
+ EnterCriticalSection(&This->lock);
+ actual_size = This->max_size;
+ if (dwOrigin == STREAM_SEEK_SET)
+ NewPosition.QuadPart = dlibMove.QuadPart;
+ else if (dwOrigin == STREAM_SEEK_CUR)
+ NewPosition.QuadPart = This->pos.QuadPart + dlibMove.QuadPart;
+ else if (dwOrigin == STREAM_SEEK_END)
+ {
+ hr = IStream_Stat(This->stream, &statstg, STATFLAG_NONAME);
+ if (SUCCEEDED(hr))
+ {
+ if (This->max_size.QuadPart + This->offset.QuadPart > statstg.cbSize.QuadPart)
+ actual_size.QuadPart = statstg.cbSize.QuadPart - This->offset.QuadPart;
+ NewPosition.QuadPart = dlibMove.QuadPart + actual_size.QuadPart;
+ }
+ }
+ else hr = E_INVALIDARG;
+
+ if (SUCCEEDED(hr) && (NewPosition.u.HighPart != 0 || NewPosition.QuadPart > actual_size.QuadPart))
+ hr = WINCODEC_ERR_VALUEOUTOFRANGE;
+
+ if (SUCCEEDED(hr)) {
+ This->pos.QuadPart = NewPosition.QuadPart;
+
+ if(plibNewPosition) plibNewPosition->QuadPart = This->pos.QuadPart;
+ }
+ LeaveCriticalSection(&This->lock);
+
+ return hr;
+}
+
+/* SetSize isn't implemented in the native windowscodecs DLL either */
+static HRESULT WINAPI StreamOnStreamRange_SetSize(IStream *iface,
+ ULARGE_INTEGER libNewSize)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+/* CopyTo isn't implemented in the native windowscodecs DLL either */
+static HRESULT WINAPI StreamOnStreamRange_CopyTo(IStream *iface,
+ IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+/* Commit isn't implemented in the native windowscodecs DLL either */
+static HRESULT WINAPI StreamOnStreamRange_Commit(IStream *iface,
+ DWORD grfCommitFlags)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+/* Revert isn't implemented in the native windowscodecs DLL either */
+static HRESULT WINAPI StreamOnStreamRange_Revert(IStream *iface)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+/* LockRegion isn't implemented in the native windowscodecs DLL either */
+static HRESULT WINAPI StreamOnStreamRange_LockRegion(IStream *iface,
+ ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+/* UnlockRegion isn't implemented in the native windowscodecs DLL either */
+static HRESULT WINAPI StreamOnStreamRange_UnlockRegion(IStream *iface,
+ ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI StreamOnStreamRange_Stat(IStream *iface,
+ STATSTG *pstatstg, DWORD grfStatFlag)
+{
+ StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
+ HRESULT hr;
+ TRACE("(%p)\n", This);
+
+ if (!pstatstg) return E_INVALIDARG;
+
+ EnterCriticalSection(&This->lock);
+ hr = IStream_Stat(This->stream, pstatstg, grfStatFlag);
+ if (SUCCEEDED(hr))
+ {
+ pstatstg->cbSize.QuadPart -= This->offset.QuadPart;
+ if (This->max_size.QuadPart < pstatstg->cbSize.QuadPart)
+ pstatstg->cbSize.QuadPart = This->max_size.QuadPart;
+ }
+
+ LeaveCriticalSection(&This->lock);
+
+ return hr;
+}
+
+/* Clone isn't implemented in the native windowscodecs DLL either */
+static HRESULT WINAPI StreamOnStreamRange_Clone(IStream *iface,
+ IStream **ppstm)
+{
+ TRACE("(%p)\n", iface);
+ return E_NOTIMPL;
+}
+
+
+static const IStreamVtbl StreamOnStreamRange_Vtbl =
+{
+ /*** IUnknown methods ***/
+ StreamOnStreamRange_QueryInterface,
+ StreamOnStreamRange_AddRef,
+ StreamOnStreamRange_Release,
+ /*** ISequentialStream methods ***/
+ StreamOnStreamRange_Read,
+ StreamOnStreamRange_Write,
+ /*** IStream methods ***/
+ StreamOnStreamRange_Seek,
+ StreamOnStreamRange_SetSize,
+ StreamOnStreamRange_CopyTo,
+ StreamOnStreamRange_Commit,
+ StreamOnStreamRange_Revert,
+ StreamOnStreamRange_LockRegion,
+ StreamOnStreamRange_UnlockRegion,
+ StreamOnStreamRange_Stat,
+ StreamOnStreamRange_Clone,
+};
+
+
/******************************************
* IWICStream implementation
*
*/
typedef struct IWICStreamImpl
{
- const IWICStreamVtbl *lpVtbl;
+ IWICStream IWICStream_iface;
LONG ref;
IStream *pStream;
} IWICStreamImpl;
+static inline IWICStreamImpl *impl_from_IWICStream(IWICStream *iface)
+{
+ return CONTAINING_RECORD(iface, IWICStreamImpl, IWICStream_iface);
+}
+
static HRESULT WINAPI IWICStreamImpl_QueryInterface(IWICStream *iface,
REFIID iid, void **ppv)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
if (!ppv) return E_INVALIDARG;
if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IStream, iid) ||
IsEqualIID(&IID_ISequentialStream, iid) || IsEqualIID(&IID_IWICStream, iid))
{
- *ppv = This;
+ *ppv = &This->IWICStream_iface;
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static ULONG WINAPI IWICStreamImpl_AddRef(IWICStream *iface)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
ULONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) refcount=%u\n", iface, ref);
static ULONG WINAPI IWICStreamImpl_Release(IWICStream *iface)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
ULONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) refcount=%u\n", iface, ref);
static HRESULT WINAPI IWICStreamImpl_Read(IWICStream *iface,
void *pv, ULONG cb, ULONG *pcbRead)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_Write(IWICStream *iface,
void const *pv, ULONG cb, ULONG *pcbWritten)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_Seek(IWICStream *iface,
LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_SetSize(IWICStream *iface,
ULARGE_INTEGER libNewSize)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_CopyTo(IWICStream *iface,
IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_Commit(IWICStream *iface,
DWORD grfCommitFlags)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_Revert(IWICStream *iface)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_LockRegion(IWICStream *iface,
ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_UnlockRegion(IWICStream *iface,
ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_Stat(IWICStream *iface,
STATSTG *pstatstg, DWORD grfStatFlag)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_Clone(IWICStream *iface,
IStream **ppstm)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
TRACE("(%p): relay\n", This);
if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
static HRESULT WINAPI IWICStreamImpl_InitializeFromIStream(IWICStream *iface,
IStream *pIStream)
{
- FIXME("(%p): stub\n", iface);
- return E_NOTIMPL;
+ ULARGE_INTEGER offset, size;
+ TRACE("(%p): relay\n", iface);
+
+ offset.QuadPart = 0;
+ size.u.LowPart = 0xffffffff;
+ size.u.HighPart = 0xffffffff;
+ return IWICStream_InitializeFromIStreamRegion(iface, pIStream, offset, size);
}
static HRESULT WINAPI IWICStreamImpl_InitializeFromFilename(IWICStream *iface,
LPCWSTR wzFileName, DWORD dwDesiredAccess)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
HRESULT hr;
DWORD dwMode;
IStream *stream;
static HRESULT WINAPI IWICStreamImpl_InitializeFromMemory(IWICStream *iface,
BYTE *pbBuffer, DWORD cbBufferSize)
{
- IWICStreamImpl *This = (IWICStreamImpl*)iface;
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
StreamOnMemory *pObject;
TRACE("(%p,%p)\n", iface, pbBuffer);
pObject = HeapAlloc(GetProcessHeap(), 0, sizeof(StreamOnMemory));
if (!pObject) return E_OUTOFMEMORY;
- pObject->lpVtbl = &StreamOnMemory_Vtbl;
+ pObject->IStream_iface.lpVtbl = &StreamOnMemory_Vtbl;
pObject->ref = 1;
pObject->pbMemory = pbBuffer;
pObject->dwMemsize = cbBufferSize;
if (InterlockedCompareExchangePointer((void**)&This->pStream, pObject, NULL))
{
/* Some other thread set the stream first. */
- IStream_Release((IStream*)pObject);
+ IStream_Release(&pObject->IStream_iface);
return WINCODEC_ERR_WRONGSTATE;
}
return S_OK;
}
+static HRESULT map_file(HANDLE file, HANDLE *map, void **mem, LARGE_INTEGER *size)
+{
+ *map = NULL;
+ if (!GetFileSizeEx(file, size)) return HRESULT_FROM_WIN32(GetLastError());
+ if (size->u.HighPart)
+ {
+ WARN("file too large\n");
+ return E_FAIL;
+ }
+ if (!(*map = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, size->u.LowPart, NULL)))
+ {
+ return HRESULT_FROM_WIN32(GetLastError());
+ }
+ if (!(*mem = MapViewOfFile(*map, FILE_MAP_READ, 0, 0, size->u.LowPart)))
+ {
+ CloseHandle(*map);
+ return HRESULT_FROM_WIN32(GetLastError());
+ }
+ return S_OK;
+}
+
+HRESULT stream_initialize_from_filehandle(IWICStream *iface, HANDLE file)
+{
+ IWICStreamImpl *This = impl_from_IWICStream(iface);
+ StreamOnFileHandle *pObject;
+ IWICStream *stream = NULL;
+ HANDLE map;
+ void *mem;
+ LARGE_INTEGER size;
+ HRESULT hr;
+ TRACE("(%p,%p)\n", iface, file);
+
+ if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
+
+ hr = map_file(file, &map, &mem, &size);
+ if (FAILED(hr)) return hr;
+
+ hr = StreamImpl_Create(&stream);
+ if (FAILED(hr)) goto error;
+
+ hr = IWICStreamImpl_InitializeFromMemory(stream, mem, size.u.LowPart);
+ if (FAILED(hr)) goto error;
+
+ pObject = HeapAlloc(GetProcessHeap(), 0, sizeof(StreamOnFileHandle));
+ if (!pObject)
+ {
+ hr = E_OUTOFMEMORY;
+ goto error;
+ }
+ pObject->IStream_iface.lpVtbl = &StreamOnFileHandle_Vtbl;
+ pObject->ref = 1;
+ pObject->map = map;
+ pObject->mem = mem;
+ pObject->stream = stream;
+
+ 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;
+
+error:
+ if (stream) IWICStream_Release(stream);
+ UnmapViewOfFile(mem);
+ CloseHandle(map);
+ return hr;
+}
+
static HRESULT WINAPI IWICStreamImpl_InitializeFromIStreamRegion(IWICStream *iface,
IStream *pIStream, ULARGE_INTEGER ulOffset, ULARGE_INTEGER ulMaxSize)
{
- FIXME("(%p): stub\n", iface);
- return E_NOTIMPL;
+ 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;
}
-const IWICStreamVtbl WICStream_Vtbl =
+static const IWICStreamVtbl WICStream_Vtbl =
{
/*** IUnknown methods ***/
IWICStreamImpl_QueryInterface,
return E_OUTOFMEMORY;
}
- pObject->lpVtbl = &WICStream_Vtbl;
+ pObject->IWICStream_iface.lpVtbl = &WICStream_Vtbl;
pObject->ref = 1;
pObject->pStream = NULL;
- *stream = (IWICStream*)pObject;
+ *stream = &pObject->IWICStream_iface;
return S_OK;
}
projects / reactos.git / blobdiff