stream.c File Reference

#include "wine/debug.h"
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "objbase.h"
#include "shlwapi.h"
#include "wincodecs_private.h"

Include dependency graph for stream.c:

Go to the source code of this file.

Classes
struct	StreamOnMemory
struct	StreamOnFileHandle
struct	StreamOnStreamRange
struct	IWICStreamImpl

Macros
#define	COBJMACROS

Typedefs
typedef struct StreamOnMemory	StreamOnMemory
typedef struct StreamOnFileHandle	StreamOnFileHandle
typedef struct StreamOnStreamRange	StreamOnStreamRange
typedef struct IWICStreamImpl	IWICStreamImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)
static StreamOnMemory *	StreamOnMemory_from_IStream (IStream *iface)
static HRESULT WINAPI	StreamOnMemory_QueryInterface (IStream *iface, REFIID iid, void **ppv)
static ULONG WINAPI	StreamOnMemory_AddRef (IStream *iface)
static ULONG WINAPI	StreamOnMemory_Release (IStream *iface)
static HRESULT WINAPI	StreamOnMemory_Read (IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
static HRESULT WINAPI	StreamOnMemory_Write (IStream *iface, void const *pv, ULONG cb, ULONG *pcbWritten)
static HRESULT WINAPI	StreamOnMemory_Seek (IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
static HRESULT WINAPI	StreamOnMemory_SetSize (IStream *iface, ULARGE_INTEGER libNewSize)
static HRESULT WINAPI	StreamOnMemory_CopyTo (IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
static HRESULT WINAPI	StreamOnMemory_Commit (IStream *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	StreamOnMemory_Revert (IStream *iface)
static HRESULT WINAPI	StreamOnMemory_LockRegion (IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	StreamOnMemory_UnlockRegion (IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	StreamOnMemory_Stat (IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
static HRESULT WINAPI	StreamOnMemory_Clone (IStream *iface, IStream **ppstm)
static StreamOnFileHandle *	StreamOnFileHandle_from_IStream (IStream *iface)
static HRESULT WINAPI	StreamOnFileHandle_QueryInterface (IStream *iface, REFIID iid, void **ppv)
static ULONG WINAPI	StreamOnFileHandle_AddRef (IStream *iface)
static ULONG WINAPI	StreamOnFileHandle_Release (IStream *iface)
static HRESULT WINAPI	StreamOnFileHandle_Read (IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
static HRESULT WINAPI	StreamOnFileHandle_Write (IStream *iface, void const *pv, ULONG cb, ULONG *pcbWritten)
static HRESULT WINAPI	StreamOnFileHandle_Seek (IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
static HRESULT WINAPI	StreamOnFileHandle_SetSize (IStream *iface, ULARGE_INTEGER libNewSize)
static HRESULT WINAPI	StreamOnFileHandle_CopyTo (IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
static HRESULT WINAPI	StreamOnFileHandle_Commit (IStream *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	StreamOnFileHandle_Revert (IStream *iface)
static HRESULT WINAPI	StreamOnFileHandle_LockRegion (IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	StreamOnFileHandle_UnlockRegion (IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	StreamOnFileHandle_Stat (IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
static HRESULT WINAPI	StreamOnFileHandle_Clone (IStream *iface, IStream **ppstm)
static StreamOnStreamRange *	StreamOnStreamRange_from_IStream (IStream *iface)
static HRESULT WINAPI	StreamOnStreamRange_QueryInterface (IStream *iface, REFIID iid, void **ppv)
static ULONG WINAPI	StreamOnStreamRange_AddRef (IStream *iface)
static ULONG WINAPI	StreamOnStreamRange_Release (IStream *iface)
static HRESULT WINAPI	StreamOnStreamRange_Read (IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
static HRESULT WINAPI	StreamOnStreamRange_Write (IStream *iface, void const *pv, ULONG cb, ULONG *pcbWritten)
static HRESULT WINAPI	StreamOnStreamRange_Seek (IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
static HRESULT WINAPI	StreamOnStreamRange_SetSize (IStream *iface, ULARGE_INTEGER libNewSize)
static HRESULT WINAPI	StreamOnStreamRange_CopyTo (IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
static HRESULT WINAPI	StreamOnStreamRange_Commit (IStream *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	StreamOnStreamRange_Revert (IStream *iface)
static HRESULT WINAPI	StreamOnStreamRange_LockRegion (IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	StreamOnStreamRange_UnlockRegion (IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	StreamOnStreamRange_Stat (IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
static HRESULT WINAPI	StreamOnStreamRange_Clone (IStream *iface, IStream **ppstm)
static IWICStreamImpl *	impl_from_IWICStream (IWICStream *iface)
static HRESULT WINAPI	IWICStreamImpl_QueryInterface (IWICStream *iface, REFIID iid, void **ppv)
static ULONG WINAPI	IWICStreamImpl_AddRef (IWICStream *iface)
static ULONG WINAPI	IWICStreamImpl_Release (IWICStream *iface)
static HRESULT WINAPI	IWICStreamImpl_Read (IWICStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
static HRESULT WINAPI	IWICStreamImpl_Write (IWICStream *iface, void const *pv, ULONG cb, ULONG *pcbWritten)
static HRESULT WINAPI	IWICStreamImpl_Seek (IWICStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
static HRESULT WINAPI	IWICStreamImpl_SetSize (IWICStream *iface, ULARGE_INTEGER libNewSize)
static HRESULT WINAPI	IWICStreamImpl_CopyTo (IWICStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
static HRESULT WINAPI	IWICStreamImpl_Commit (IWICStream *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	IWICStreamImpl_Revert (IWICStream *iface)
static HRESULT WINAPI	IWICStreamImpl_LockRegion (IWICStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	IWICStreamImpl_UnlockRegion (IWICStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	IWICStreamImpl_Stat (IWICStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
static HRESULT WINAPI	IWICStreamImpl_Clone (IWICStream *iface, IStream **ppstm)
static HRESULT WINAPI	IWICStreamImpl_InitializeFromIStream (IWICStream *iface, IStream *stream)
static HRESULT WINAPI	IWICStreamImpl_InitializeFromFilename (IWICStream *iface, LPCWSTR wzFileName, DWORD dwDesiredAccess)
static HRESULT WINAPI	IWICStreamImpl_InitializeFromMemory (IWICStream *iface, BYTE *pbBuffer, DWORD cbBufferSize)
static HRESULT	map_file (HANDLE file, HANDLE *map, void **mem, LARGE_INTEGER *size)
HRESULT	stream_initialize_from_filehandle (IWICStream *iface, HANDLE file)
static HRESULT WINAPI	IWICStreamImpl_InitializeFromIStreamRegion (IWICStream *iface, IStream *pIStream, ULARGE_INTEGER ulOffset, ULARGE_INTEGER ulMaxSize)
HRESULT	StreamImpl_Create (IWICStream **stream)

Variables
static const IStreamVtbl	StreamOnMemory_Vtbl
static const IStreamVtbl	StreamOnFileHandle_Vtbl
static const IStreamVtbl	StreamOnStreamRange_Vtbl
static const IWICStreamVtbl	WICStream_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file stream.c.

Typedef Documentation

IWICStreamImpl

typedef struct IWICStreamImpl IWICStreamImpl

StreamOnFileHandle

typedef struct StreamOnFileHandle StreamOnFileHandle

StreamOnMemory

typedef struct StreamOnMemory StreamOnMemory

StreamOnStreamRange

typedef struct StreamOnStreamRange StreamOnStreamRange

Function Documentation

impl_from_IWICStream()

static IWICStreamImpl * impl_from_IWICStream ( IWICStream *  iface )

inlinestatic

Definition at line 752 of file stream.c.

{
    return CONTAINING_RECORD(iface, IWICStreamImpl, IWICStream_iface);
}

Referenced by IWICStreamImpl_AddRef(), IWICStreamImpl_Clone(), IWICStreamImpl_Commit(), IWICStreamImpl_CopyTo(), IWICStreamImpl_InitializeFromFilename(), IWICStreamImpl_InitializeFromIStream(), IWICStreamImpl_InitializeFromIStreamRegion(), IWICStreamImpl_InitializeFromMemory(), IWICStreamImpl_LockRegion(), IWICStreamImpl_QueryInterface(), IWICStreamImpl_Read(), IWICStreamImpl_Release(), IWICStreamImpl_Revert(), IWICStreamImpl_Seek(), IWICStreamImpl_SetSize(), IWICStreamImpl_Stat(), IWICStreamImpl_UnlockRegion(), IWICStreamImpl_Write(), and stream_initialize_from_filehandle().

IWICStreamImpl_AddRef()

static ULONG WINAPI IWICStreamImpl_AddRef ( IWICStream *  iface )

static

Definition at line 779 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    return ref;
}

IWICStreamImpl_Clone()

static HRESULT WINAPI IWICStreamImpl_Clone ( IWICStream *  iface, IStream **  ppstm  )

static

Definition at line 905 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %p)\n", This, ppstm);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_Clone(This->pStream, ppstm);
}

IWICStreamImpl_Commit()

static HRESULT WINAPI IWICStreamImpl_Commit ( IWICStream *  iface, DWORD  grfCommitFlags  )

static

Definition at line 854 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %#x)\n", This, grfCommitFlags);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_Commit(This->pStream, grfCommitFlags);
}

IWICStreamImpl_CopyTo()

static HRESULT WINAPI IWICStreamImpl_CopyTo ( IWICStream *  iface, IStream *  pstm, ULARGE_INTEGER  cb, ULARGE_INTEGER *  pcbRead, ULARGE_INTEGER *  pcbWritten  )

static

Definition at line 844 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %p, %s, %p, %p)\n", This, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_CopyTo(This->pStream, pstm, cb, pcbRead, pcbWritten);
}

IWICStreamImpl_InitializeFromFilename()

static HRESULT WINAPI IWICStreamImpl_InitializeFromFilename ( IWICStream *  iface, LPCWSTR  wzFileName, DWORD  dwDesiredAccess  )

static

Definition at line 937 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    HRESULT hr;
    DWORD dwMode;
    IStream *stream;
 
    TRACE("(%p, %s, %u)\n", iface, debugstr_w(wzFileName), dwDesiredAccess);
 
    if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
 
    if(dwDesiredAccess & GENERIC_WRITE)
        dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
    else if(dwDesiredAccess & GENERIC_READ)
        dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
    else
        return E_INVALIDARG;
 
    hr = SHCreateStreamOnFileW(wzFileName, dwMode, &stream);
 
    if (SUCCEEDED(hr))
    {
        if (InterlockedCompareExchangePointer((void**)&This->pStream, stream, NULL))
        {
            /* Some other thread set the stream first. */
            IStream_Release(stream);
            hr = WINCODEC_ERR_WRONGSTATE;
        }
    }
 
    return hr;
}

IWICStreamImpl_InitializeFromIStream()

static HRESULT WINAPI IWICStreamImpl_InitializeFromIStream ( IWICStream *  iface, IStream *  stream  )

static

Definition at line 915 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    HRESULT hr = S_OK;
 
    TRACE("(%p, %p)\n", iface, stream);
 
    if (!stream) return E_INVALIDARG;
    if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
 
    IStream_AddRef(stream);
 
    if (InterlockedCompareExchangePointer((void **)&This->pStream, stream, NULL))
    {
        /* Some other thread set the stream first. */
        IStream_Release(stream);
        hr = WINCODEC_ERR_WRONGSTATE;
    }
 
    return hr;
}

IWICStreamImpl_InitializeFromIStreamRegion()

static HRESULT WINAPI IWICStreamImpl_InitializeFromIStreamRegion ( IWICStream *  iface, IStream *  pIStream, ULARGE_INTEGER  ulOffset, ULARGE_INTEGER  ulMaxSize  )

static

Definition at line 1088 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    StreamOnStreamRange *pObject;
 
    TRACE("(%p,%p,%s,%s)\n", iface, pIStream, wine_dbgstr_longlong(ulOffset.QuadPart),
        wine_dbgstr_longlong(ulMaxSize.QuadPart));
 
    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;
}

IWICStreamImpl_InitializeFromMemory()

static HRESULT WINAPI IWICStreamImpl_InitializeFromMemory ( IWICStream *  iface, BYTE *  pbBuffer, DWORD  cbBufferSize  )

static

Definition at line 987 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    StreamOnMemory *pObject;
    TRACE("(%p, %p, %u)\n", iface, pbBuffer, cbBufferSize);
 
    if (!pbBuffer) return E_INVALIDARG;
    if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
 
    pObject = HeapAlloc(GetProcessHeap(), 0, sizeof(StreamOnMemory));
    if (!pObject) return E_OUTOFMEMORY;
 
    pObject->IStream_iface.lpVtbl = &StreamOnMemory_Vtbl;
    pObject->ref = 1;
    pObject->pbMemory = pbBuffer;
    pObject->dwMemsize = cbBufferSize;
    pObject->dwCurPos = 0;
    InitializeCriticalSection(&pObject->lock);
    pObject->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": StreamOnMemory.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;
}

Referenced by stream_initialize_from_filehandle().

IWICStreamImpl_LockRegion()

static HRESULT WINAPI IWICStreamImpl_LockRegion ( IWICStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 873 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %s, %s, %d)\n", This, wine_dbgstr_longlong(libOffset.QuadPart),
        wine_dbgstr_longlong(cb.QuadPart), dwLockType);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_LockRegion(This->pStream, libOffset, cb, dwLockType);
}

IWICStreamImpl_QueryInterface()

static HRESULT WINAPI IWICStreamImpl_QueryInterface ( IWICStream *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 757 of file stream.c.

{
    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->IWICStream_iface;
        IUnknown_AddRef((IUnknown*)*ppv);
        return S_OK;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
}

IWICStreamImpl_Read()

static HRESULT WINAPI IWICStreamImpl_Read ( IWICStream *  iface, void *  pv, ULONG  cb, ULONG *  pcbRead  )

static

Definition at line 803 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %p, %u, %p)\n", This, pv, cb, pcbRead);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_Read(This->pStream, pv, cb, pcbRead);
}

IWICStreamImpl_Release()

static ULONG WINAPI IWICStreamImpl_Release ( IWICStream *  iface )

static

Definition at line 789 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0) {
        if (This->pStream) IStream_Release(This->pStream);
        HeapFree(GetProcessHeap(), 0, This);
    }
    return ref;
}

IWICStreamImpl_Revert()

static HRESULT WINAPI IWICStreamImpl_Revert ( IWICStream *  iface )

static

Definition at line 864 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p)\n", This);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_Revert(This->pStream);
}

IWICStreamImpl_Seek()

static HRESULT WINAPI IWICStreamImpl_Seek ( IWICStream *  iface, LARGE_INTEGER  dlibMove, DWORD  dwOrigin, ULARGE_INTEGER *  plibNewPosition  )

static

Definition at line 823 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %s, %d, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart),
        dwOrigin, plibNewPosition);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_Seek(This->pStream, dlibMove, dwOrigin, plibNewPosition);
}

IWICStreamImpl_SetSize()

static HRESULT WINAPI IWICStreamImpl_SetSize ( IWICStream *  iface, ULARGE_INTEGER  libNewSize  )

static

Definition at line 834 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %s)\n", This, wine_dbgstr_longlong(libNewSize.QuadPart));
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_SetSize(This->pStream, libNewSize);
}

IWICStreamImpl_Stat()

static HRESULT WINAPI IWICStreamImpl_Stat ( IWICStream *  iface, STATSTG *  pstatstg, DWORD  grfStatFlag  )

static

Definition at line 895 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %p, %#x)\n", This, pstatstg, grfStatFlag);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_Stat(This->pStream, pstatstg, grfStatFlag);
}

IWICStreamImpl_UnlockRegion()

static HRESULT WINAPI IWICStreamImpl_UnlockRegion ( IWICStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 884 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %s, %s, %d)\n", This, wine_dbgstr_longlong(libOffset.QuadPart),
        wine_dbgstr_longlong(cb.QuadPart), dwLockType);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_UnlockRegion(This->pStream, libOffset, cb, dwLockType);
}

IWICStreamImpl_Write()

static HRESULT WINAPI IWICStreamImpl_Write ( IWICStream *  iface, void const *  pv, ULONG  cb, ULONG *  pcbWritten  )

static

Definition at line 813 of file stream.c.

{
    IWICStreamImpl *This = impl_from_IWICStream(iface);
    TRACE("(%p, %p, %u, %p)\n", This, pv, cb, pcbWritten);
 
    if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
    return IStream_Write(This->pStream, pv, cb, pcbWritten);
}

map_file()

static HRESULT map_file ( HANDLE  file, HANDLE *  map, void **  mem, LARGE_INTEGER *  size  )

static

Definition at line 1018 of file stream.c.

{
    *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;
}

Referenced by stream_initialize_from_filehandle().

stream_initialize_from_filehandle()

HRESULT stream_initialize_from_filehandle	(	IWICStream *	iface,
		HANDLE	file
	)

Definition at line 1039 of file stream.c.

{
    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;
}

Referenced by ImagingFactory_CreateDecoderFromFileHandle().

StreamImpl_Create()

HRESULT StreamImpl_Create

(

IWICStream **

stream

)

Definition at line 1150 of file stream.c.

{
    IWICStreamImpl *pObject;
 
    if( !stream ) return E_INVALIDARG;
 
    pObject = HeapAlloc(GetProcessHeap(), 0, sizeof(IWICStreamImpl));
    if( !pObject ) {
        *stream = NULL;
        return E_OUTOFMEMORY;
    }
 
    pObject->IWICStream_iface.lpVtbl = &WICStream_Vtbl;
    pObject->ref = 1;
    pObject->pStream = NULL;
 
    *stream = &pObject->IWICStream_iface;
 
    return S_OK;
}

Referenced by IcoDecoder_GetFrame(), ImagingFactory_CreateDecoderFromFileHandle(), ImagingFactory_CreateDecoderFromFilename(), ImagingFactory_CreateStream(), and stream_initialize_from_filehandle().

StreamOnFileHandle_AddRef()

static ULONG WINAPI StreamOnFileHandle_AddRef ( IStream *  iface )

static

Definition at line 309 of file stream.c.

{
    StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    return ref;
}

StreamOnFileHandle_Clone()

static HRESULT WINAPI StreamOnFileHandle_Clone ( IStream *  iface, IStream **  ppstm  )

static

Definition at line 412 of file stream.c.

{
    TRACE("(%p, %p)\n", iface, ppstm);
    return E_NOTIMPL;
}

StreamOnFileHandle_Commit()

static HRESULT WINAPI StreamOnFileHandle_Commit ( IStream *  iface, DWORD  grfCommitFlags  )

static

Definition at line 374 of file stream.c.

{
    TRACE("(%p, %#x)\n", iface, grfCommitFlags);
    return E_NOTIMPL;
}

StreamOnFileHandle_CopyTo()

static HRESULT WINAPI StreamOnFileHandle_CopyTo ( IStream *  iface, IStream *  pstm, ULARGE_INTEGER  cb, ULARGE_INTEGER *  pcbRead, ULARGE_INTEGER *  pcbWritten  )

static

Definition at line 367 of file stream.c.

{
    TRACE("(%p, %p, %s, %p, %p)\n", iface, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
    return E_NOTIMPL;
}

StreamOnFileHandle_from_IStream()

static StreamOnFileHandle * StreamOnFileHandle_from_IStream ( IStream *  iface )

inlinestatic

Definition at line 283 of file stream.c.

{
    return CONTAINING_RECORD(iface, StreamOnFileHandle, IStream_iface);
}

Referenced by StreamOnFileHandle_AddRef(), StreamOnFileHandle_Read(), StreamOnFileHandle_Release(), StreamOnFileHandle_Seek(), and StreamOnFileHandle_Stat().

StreamOnFileHandle_LockRegion()

static HRESULT WINAPI StreamOnFileHandle_LockRegion ( IStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 387 of file stream.c.

{
    TRACE("(%p, %s, %s, %d)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
        wine_dbgstr_longlong(cb.QuadPart), dwLockType);
    return E_NOTIMPL;
}

StreamOnFileHandle_QueryInterface()

static HRESULT WINAPI StreamOnFileHandle_QueryInterface ( IStream *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 288 of file stream.c.

{
    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;
    }
}

StreamOnFileHandle_Read()

static HRESULT WINAPI StreamOnFileHandle_Read ( IStream *  iface, void *  pv, ULONG  cb, ULONG *  pcbRead  )

static

Definition at line 335 of file stream.c.

{
    StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
    TRACE("(%p, %p, %u, %p)\n", This, pv, cb, pcbRead);
 
    return IWICStream_Read(This->stream, pv, cb, pcbRead);
}

StreamOnFileHandle_Release()

static ULONG WINAPI StreamOnFileHandle_Release ( IStream *  iface )

static

Definition at line 319 of file stream.c.

{
    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;
}

StreamOnFileHandle_Revert()

static HRESULT WINAPI StreamOnFileHandle_Revert ( IStream *  iface )

static

Definition at line 381 of file stream.c.

{
    TRACE("(%p)\n", iface);
    return E_NOTIMPL;
}

StreamOnFileHandle_Seek()

static HRESULT WINAPI StreamOnFileHandle_Seek ( IStream *  iface, LARGE_INTEGER  dlibMove, DWORD  dwOrigin, ULARGE_INTEGER *  plibNewPosition  )

static

Definition at line 351 of file stream.c.

{
    StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
    TRACE("(%p, %s, %d, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
 
    return IWICStream_Seek(This->stream, dlibMove, dwOrigin, plibNewPosition);
}

StreamOnFileHandle_SetSize()

static HRESULT WINAPI StreamOnFileHandle_SetSize ( IStream *  iface, ULARGE_INTEGER  libNewSize  )

static

Definition at line 360 of file stream.c.

{
    TRACE("(%p, %s)\n", iface, wine_dbgstr_longlong(libNewSize.QuadPart));
    return E_NOTIMPL;
}

StreamOnFileHandle_Stat()

static HRESULT WINAPI StreamOnFileHandle_Stat ( IStream *  iface, STATSTG *  pstatstg, DWORD  grfStatFlag  )

static

Definition at line 403 of file stream.c.

{
    StreamOnFileHandle *This = StreamOnFileHandle_from_IStream(iface);
    TRACE("(%p, %p, %#x)\n", This, pstatstg, grfStatFlag);
 
    return IWICStream_Stat(This->stream, pstatstg, grfStatFlag);
}

StreamOnFileHandle_UnlockRegion()

static HRESULT WINAPI StreamOnFileHandle_UnlockRegion ( IStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 395 of file stream.c.

{
    TRACE("(%p, %s, %s, %d)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
        wine_dbgstr_longlong(cb.QuadPart), dwLockType);
    return E_NOTIMPL;
}

StreamOnFileHandle_Write()

static HRESULT WINAPI StreamOnFileHandle_Write ( IStream *  iface, void const *  pv, ULONG  cb, ULONG *  pcbWritten  )

static

Definition at line 344 of file stream.c.

{
    ERR("(%p, %p, %u, %p)\n", iface, pv, cb, pcbWritten);
    return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
}

StreamOnMemory_AddRef()

static ULONG WINAPI StreamOnMemory_AddRef ( IStream *  iface )

static

Definition at line 74 of file stream.c.

{
    StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    return ref;
}

StreamOnMemory_Clone()

static HRESULT WINAPI StreamOnMemory_Clone ( IStream *  iface, IStream **  ppstm  )

static

Definition at line 241 of file stream.c.

{
    TRACE("(%p, %p)\n", iface, ppstm);
    return E_NOTIMPL;
}

StreamOnMemory_Commit()

static HRESULT WINAPI StreamOnMemory_Commit ( IStream *  iface, DWORD  grfCommitFlags  )

static

Definition at line 193 of file stream.c.

{
    TRACE("(%p, %#x)\n", iface, grfCommitFlags);
    return E_NOTIMPL;
}

StreamOnMemory_CopyTo()

static HRESULT WINAPI StreamOnMemory_CopyTo ( IStream *  iface, IStream *  pstm, ULARGE_INTEGER  cb, ULARGE_INTEGER *  pcbRead, ULARGE_INTEGER *  pcbWritten  )

static

Definition at line 185 of file stream.c.

{
    TRACE("(%p, %p, %s, %p, %p)\n", iface, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
    return E_NOTIMPL;
}

StreamOnMemory_from_IStream()

static StreamOnMemory * StreamOnMemory_from_IStream ( IStream *  iface )

inlinestatic

Definition at line 48 of file stream.c.

{
    return CONTAINING_RECORD(iface, StreamOnMemory, IStream_iface);
}

Referenced by StreamOnMemory_AddRef(), StreamOnMemory_Read(), StreamOnMemory_Release(), StreamOnMemory_Seek(), StreamOnMemory_Stat(), and StreamOnMemory_Write().

StreamOnMemory_LockRegion()

static HRESULT WINAPI StreamOnMemory_LockRegion ( IStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 208 of file stream.c.

{
    TRACE("(%p, %s, %s, %d)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
        wine_dbgstr_longlong(cb.QuadPart), dwLockType);
    return E_NOTIMPL;
}

StreamOnMemory_QueryInterface()

static HRESULT WINAPI StreamOnMemory_QueryInterface ( IStream *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 53 of file stream.c.

{
    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;
    }
}

StreamOnMemory_Read()

static HRESULT WINAPI StreamOnMemory_Read ( IStream *  iface, void *  pv, ULONG  cb, ULONG *  pcbRead  )

static

Definition at line 99 of file stream.c.

{
    StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
    ULONG uBytesRead;
 
    TRACE("(%p, %p, %u, %p)\n", This, pv, cb, pcbRead);
 
    if (!pv) return E_INVALIDARG;
 
    EnterCriticalSection(&This->lock);
    uBytesRead = min(cb, This->dwMemsize - This->dwCurPos);
    memmove(pv, This->pbMemory + This->dwCurPos, uBytesRead);
    This->dwCurPos += uBytesRead;
    LeaveCriticalSection(&This->lock);
 
    if (pcbRead) *pcbRead = uBytesRead;
 
    return S_OK;
}

StreamOnMemory_Release()

static ULONG WINAPI StreamOnMemory_Release ( IStream *  iface )

static

Definition at line 84 of file stream.c.

{
    StreamOnMemory *This = StreamOnMemory_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);
        HeapFree(GetProcessHeap(), 0, This);
    }
    return ref;
}

StreamOnMemory_Revert()

static HRESULT WINAPI StreamOnMemory_Revert ( IStream *  iface )

static

Definition at line 201 of file stream.c.

{
    TRACE("(%p)\n", iface);
    return E_NOTIMPL;
}

StreamOnMemory_Seek()

static HRESULT WINAPI StreamOnMemory_Seek ( IStream *  iface, LARGE_INTEGER  dlibMove, DWORD  dwOrigin, ULARGE_INTEGER *  plibNewPosition  )

static

Definition at line 145 of file stream.c.

{
    StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
    LARGE_INTEGER NewPosition;
    HRESULT hr=S_OK;
 
    TRACE("(%p, %s, %d, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
 
    EnterCriticalSection(&This->lock);
    if (dwOrigin == STREAM_SEEK_SET) NewPosition.QuadPart = dlibMove.QuadPart;
    else if (dwOrigin == STREAM_SEEK_CUR) NewPosition.QuadPart = This->dwCurPos + dlibMove.QuadPart;
    else if (dwOrigin == STREAM_SEEK_END) NewPosition.QuadPart = This->dwMemsize + dlibMove.QuadPart;
    else hr = E_INVALIDARG;
 
    if (SUCCEEDED(hr)) {
        if (NewPosition.u.HighPart) hr = HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
        else if (NewPosition.QuadPart > This->dwMemsize) hr = E_INVALIDARG;
        else if (NewPosition.QuadPart < 0) hr = E_INVALIDARG;
    }
 
    if (SUCCEEDED(hr)) {
        This->dwCurPos = NewPosition.u.LowPart;
 
        if(plibNewPosition) plibNewPosition->QuadPart = This->dwCurPos;
    }
    LeaveCriticalSection(&This->lock);
 
    return hr;
}

StreamOnMemory_SetSize()

static HRESULT WINAPI StreamOnMemory_SetSize ( IStream *  iface, ULARGE_INTEGER  libNewSize  )

static

Definition at line 177 of file stream.c.

{
    TRACE("(%p, %s)\n", iface, wine_dbgstr_longlong(libNewSize.QuadPart));
    return E_NOTIMPL;
}

StreamOnMemory_Stat()

static HRESULT WINAPI StreamOnMemory_Stat ( IStream *  iface, STATSTG *  pstatstg, DWORD  grfStatFlag  )

static

Definition at line 225 of file stream.c.

{
    StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
    TRACE("(%p, %p, %#x)\n", This, pstatstg, grfStatFlag);
 
    if (!pstatstg) return E_INVALIDARG;
 
    ZeroMemory(pstatstg, sizeof(STATSTG));
    pstatstg->type = STGTY_STREAM;
    pstatstg->cbSize.QuadPart = This->dwMemsize;
 
    return S_OK;
}

StreamOnMemory_UnlockRegion()

static HRESULT WINAPI StreamOnMemory_UnlockRegion ( IStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 217 of file stream.c.

{
    TRACE("(%p, %s, %s, %d)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
        wine_dbgstr_longlong(cb.QuadPart), dwLockType);
    return E_NOTIMPL;
}

StreamOnMemory_Write()

static HRESULT WINAPI StreamOnMemory_Write ( IStream *  iface, void const *  pv, ULONG  cb, ULONG *  pcbWritten  )

static

Definition at line 120 of file stream.c.

{
    StreamOnMemory *This = StreamOnMemory_from_IStream(iface);
    HRESULT hr;
 
    TRACE("(%p, %p, %u, %p)\n", This, pv, cb, pcbWritten);
 
    if (!pv) return E_INVALIDARG;
 
    EnterCriticalSection(&This->lock);
    if (cb > This->dwMemsize - This->dwCurPos) {
        hr = STG_E_MEDIUMFULL;
    }
    else {
        memmove(This->pbMemory + This->dwCurPos, pv, cb);
        This->dwCurPos += cb;
        hr = S_OK;
        if (pcbWritten) *pcbWritten = cb;
    }
    LeaveCriticalSection(&This->lock);
 
    return hr;
}

StreamOnStreamRange_AddRef()

static ULONG WINAPI StreamOnStreamRange_AddRef ( IStream *  iface )

static

Definition at line 484 of file stream.c.

{
    StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    return ref;
}

StreamOnStreamRange_Clone()

static HRESULT WINAPI StreamOnStreamRange_Clone ( IStream *  iface, IStream **  ppstm  )

static

Definition at line 711 of file stream.c.

{
    TRACE("(%p, %p)\n", iface, ppstm);
    return E_NOTIMPL;
}

StreamOnStreamRange_Commit()

static HRESULT WINAPI StreamOnStreamRange_Commit ( IStream *  iface, DWORD  grfCommitFlags  )

static

Definition at line 655 of file stream.c.

{
    TRACE("(%p, %#x)\n", iface, grfCommitFlags);
    return E_NOTIMPL;
}

StreamOnStreamRange_CopyTo()

static HRESULT WINAPI StreamOnStreamRange_CopyTo ( IStream *  iface, IStream *  pstm, ULARGE_INTEGER  cb, ULARGE_INTEGER *  pcbRead, ULARGE_INTEGER *  pcbWritten  )

static

Definition at line 646 of file stream.c.

{
    TRACE("(%p, %p, %s, %p, %p)\n", iface, pstm, wine_dbgstr_longlong(cb.QuadPart),
        pcbRead, pcbWritten);
    return E_NOTIMPL;
}

StreamOnStreamRange_from_IStream()

static StreamOnStreamRange * StreamOnStreamRange_from_IStream ( IStream *  iface )

inlinestatic

Definition at line 458 of file stream.c.

{
    return CONTAINING_RECORD(iface, StreamOnStreamRange, IStream_iface);
}

Referenced by StreamOnStreamRange_AddRef(), StreamOnStreamRange_Read(), StreamOnStreamRange_Release(), StreamOnStreamRange_Seek(), StreamOnStreamRange_Stat(), and StreamOnStreamRange_Write().

StreamOnStreamRange_LockRegion()

static HRESULT WINAPI StreamOnStreamRange_LockRegion ( IStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 670 of file stream.c.

{
    TRACE("(%p, %s, %s, %d)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
        wine_dbgstr_longlong(cb.QuadPart), dwLockType);
    return E_NOTIMPL;
}

StreamOnStreamRange_QueryInterface()

static HRESULT WINAPI StreamOnStreamRange_QueryInterface ( IStream *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 463 of file stream.c.

{
    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;
    }
}

StreamOnStreamRange_Read()

static HRESULT WINAPI StreamOnStreamRange_Read ( IStream *  iface, void *  pv, ULONG  cb, ULONG *  pcbRead  )

static

Definition at line 510 of file stream.c.

{
    StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
    ULONG uBytesRead=0;
    HRESULT hr;
    ULARGE_INTEGER OldPosition;
    LARGE_INTEGER SetPosition;
 
    TRACE("(%p, %p, %u, %p)\n", This, pv, cb, pcbRead);
 
    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;
}

StreamOnStreamRange_Release()

static ULONG WINAPI StreamOnStreamRange_Release ( IStream *  iface )

static

Definition at line 494 of file stream.c.

{
    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;
}

StreamOnStreamRange_Revert()

static HRESULT WINAPI StreamOnStreamRange_Revert ( IStream *  iface )

static

Definition at line 663 of file stream.c.

{
    TRACE("(%p)\n", iface);
    return E_NOTIMPL;
}

StreamOnStreamRange_Seek()

static HRESULT WINAPI StreamOnStreamRange_Seek ( IStream *  iface, LARGE_INTEGER  dlibMove, DWORD  dwOrigin, ULARGE_INTEGER *  plibNewPosition  )

static

Definition at line 597 of file stream.c.

{
    StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
    ULARGE_INTEGER NewPosition, actual_size;
    HRESULT hr=S_OK;
    STATSTG statstg;
    TRACE("(%p, %s, %d, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
 
    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;
}

StreamOnStreamRange_SetSize()

static HRESULT WINAPI StreamOnStreamRange_SetSize ( IStream *  iface, ULARGE_INTEGER  libNewSize  )

static

Definition at line 638 of file stream.c.

{
    TRACE("(%p, %s)\n", iface, wine_dbgstr_longlong(libNewSize.QuadPart));
    return E_NOTIMPL;
}

StreamOnStreamRange_Stat()

static HRESULT WINAPI StreamOnStreamRange_Stat ( IStream *  iface, STATSTG *  pstatstg, DWORD  grfStatFlag  )

static

Definition at line 687 of file stream.c.

{
    StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
    HRESULT hr;
    TRACE("(%p, %p, %#x)\n", This, pstatstg, grfStatFlag);
 
    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;
}

StreamOnStreamRange_UnlockRegion()

static HRESULT WINAPI StreamOnStreamRange_UnlockRegion ( IStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 679 of file stream.c.

{
    TRACE("(%p, %s, %s, %d)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
        wine_dbgstr_longlong(cb.QuadPart), dwLockType);
    return E_NOTIMPL;
}

StreamOnStreamRange_Write()

static HRESULT WINAPI StreamOnStreamRange_Write ( IStream *  iface, void const *  pv, ULONG  cb, ULONG *  pcbWritten  )

static

Definition at line 554 of file stream.c.

{
    StreamOnStreamRange *This = StreamOnStreamRange_from_IStream(iface);
    HRESULT hr;
    ULARGE_INTEGER OldPosition;
    LARGE_INTEGER SetPosition;
    ULONG uBytesWritten=0;
    TRACE("(%p, %p, %u, %p)\n", This, pv, cb, pcbWritten);
 
    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;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wincodecs

)

Variable Documentation

StreamOnFileHandle_Vtbl

const IStreamVtbl StreamOnFileHandle_Vtbl

static

Initial value:

=
{
    
    StreamOnFileHandle_QueryInterface,
    StreamOnFileHandle_AddRef,
    StreamOnFileHandle_Release,
    
    StreamOnFileHandle_Read,
    StreamOnFileHandle_Write,
    
    StreamOnFileHandle_Seek,
    StreamOnFileHandle_SetSize,
    StreamOnFileHandle_CopyTo,
    StreamOnFileHandle_Commit,
    StreamOnFileHandle_Revert,
    StreamOnFileHandle_LockRegion,
    StreamOnFileHandle_UnlockRegion,
    StreamOnFileHandle_Stat,
    StreamOnFileHandle_Clone,
}

Definition at line 419 of file stream.c.

Referenced by stream_initialize_from_filehandle().

StreamOnMemory_Vtbl

const IStreamVtbl StreamOnMemory_Vtbl

static

Initial value:

=
{
    
    StreamOnMemory_QueryInterface,
    StreamOnMemory_AddRef,
    StreamOnMemory_Release,
    
    StreamOnMemory_Read,
    StreamOnMemory_Write,
    
    StreamOnMemory_Seek,
    StreamOnMemory_SetSize,
    StreamOnMemory_CopyTo,
    StreamOnMemory_Commit,
    StreamOnMemory_Revert,
    StreamOnMemory_LockRegion,
    StreamOnMemory_UnlockRegion,
    StreamOnMemory_Stat,
    StreamOnMemory_Clone,
}

Definition at line 249 of file stream.c.

Referenced by IWICStreamImpl_InitializeFromMemory().

StreamOnStreamRange_Vtbl

const IStreamVtbl StreamOnStreamRange_Vtbl

static

Initial value:

=
{
    
    StreamOnStreamRange_QueryInterface,
    StreamOnStreamRange_AddRef,
    StreamOnStreamRange_Release,
    
    StreamOnStreamRange_Read,
    StreamOnStreamRange_Write,
    
    StreamOnStreamRange_Seek,
    StreamOnStreamRange_SetSize,
    StreamOnStreamRange_CopyTo,
    StreamOnStreamRange_Commit,
    StreamOnStreamRange_Revert,
    StreamOnStreamRange_LockRegion,
    StreamOnStreamRange_UnlockRegion,
    StreamOnStreamRange_Stat,
    StreamOnStreamRange_Clone,
}

Definition at line 718 of file stream.c.

Referenced by IWICStreamImpl_InitializeFromIStreamRegion().

WICStream_Vtbl

const IWICStreamVtbl WICStream_Vtbl

static

Initial value:

=
{
    
    IWICStreamImpl_QueryInterface,
    IWICStreamImpl_AddRef,
    IWICStreamImpl_Release,
    
    IWICStreamImpl_Read,
    IWICStreamImpl_Write,
    
    IWICStreamImpl_Seek,
    IWICStreamImpl_SetSize,
    IWICStreamImpl_CopyTo,
    IWICStreamImpl_Commit,
    IWICStreamImpl_Revert,
    IWICStreamImpl_LockRegion,
    IWICStreamImpl_UnlockRegion,
    IWICStreamImpl_Stat,
    IWICStreamImpl_Clone,
    
    IWICStreamImpl_InitializeFromIStream,
    IWICStreamImpl_InitializeFromFilename,
    IWICStreamImpl_InitializeFromMemory,
    IWICStreamImpl_InitializeFromIStreamRegion,
}

Definition at line 1124 of file stream.c.

Referenced by StreamImpl_Create().