ReactOS 0.4.16-dev-838-g27bb510
stream.c
Go to the documentation of this file.
1/*
2 * Copyright 2009 Tony Wasserka
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19#include "wine/debug.h"
20
21#define COBJMACROS
22#include "windef.h"
23#include "winbase.h"
24#include "winreg.h"
25#include "objbase.h"
26#include "shlwapi.h"
27#include "wincodecs_private.h"
28
30
31/******************************************
32 * StreamOnMemory implementation
33 *
34 * Used by IWICStream_InitializeFromMemory
35 *
36 */
37typedef struct StreamOnMemory {
40
44
45 CRITICAL_SECTION lock; /* must be held when pbMemory or dwCurPos is accessed */
47
49{
50 return CONTAINING_RECORD(iface, StreamOnMemory, IStream_iface);
51}
52
54 REFIID iid, void **ppv)
55{
56 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
57
58 if (!ppv) return E_INVALIDARG;
59
60 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IStream, iid) ||
61 IsEqualIID(&IID_ISequentialStream, iid))
62 {
63 *ppv = iface;
64 IUnknown_AddRef((IUnknown*)*ppv);
65 return S_OK;
66 }
67 else
68 {
69 *ppv = NULL;
70 return E_NOINTERFACE;
71 }
72}
73
75{
78
79 TRACE("(%p) refcount=%lu\n", iface, ref);
80
81 return ref;
82}
83
85{
88
89 TRACE("(%p) refcount=%lu\n", iface, ref);
90
91 if (ref == 0) {
92 This->lock.DebugInfo->Spare[0] = 0;
94 free(This);
95 }
96 return ref;
97}
98
100 void *pv, ULONG cb, ULONG *pcbRead)
101{
103 ULONG uBytesRead;
104
105 TRACE("(%p, %p, %lu, %p)\n", This, pv, cb, pcbRead);
106
107 if (!pv) return E_INVALIDARG;
108
110 uBytesRead = min(cb, This->dwMemsize - This->dwCurPos);
111 memmove(pv, This->pbMemory + This->dwCurPos, uBytesRead);
112 This->dwCurPos += uBytesRead;
114
115 if (pcbRead) *pcbRead = uBytesRead;
116
117 return S_OK;
118}
119
121 void const *pv, ULONG cb, ULONG *pcbWritten)
122{
124 HRESULT hr;
125
126 TRACE("(%p, %p, %lu, %p)\n", This, pv, cb, pcbWritten);
127
128 if (!pv) return E_INVALIDARG;
129
131 if (cb > This->dwMemsize - This->dwCurPos) {
133 }
134 else {
135 memmove(This->pbMemory + This->dwCurPos, pv, cb);
136 This->dwCurPos += cb;
137 hr = S_OK;
138 if (pcbWritten) *pcbWritten = cb;
139 }
141
142 return hr;
143}
144
146 LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
147{
149 LARGE_INTEGER NewPosition;
151
152 TRACE("(%p, %s, %ld, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
153
155 if (dwOrigin == STREAM_SEEK_SET) NewPosition.QuadPart = dlibMove.QuadPart;
156 else if (dwOrigin == STREAM_SEEK_CUR) NewPosition.QuadPart = This->dwCurPos + dlibMove.QuadPart;
157 else if (dwOrigin == STREAM_SEEK_END) NewPosition.QuadPart = This->dwMemsize + dlibMove.QuadPart;
158 else hr = E_INVALIDARG;
159
160 if (SUCCEEDED(hr)) {
161 if (NewPosition.u.HighPart) hr = HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
162 else if (NewPosition.QuadPart > This->dwMemsize) hr = E_INVALIDARG;
163 else if (NewPosition.QuadPart < 0) hr = E_INVALIDARG;
164 }
165
166 if (SUCCEEDED(hr)) {
167 This->dwCurPos = NewPosition.u.LowPart;
168
169 if(plibNewPosition) plibNewPosition->QuadPart = This->dwCurPos;
170 }
172
173 return hr;
174}
175
176/* SetSize isn't implemented in the native windowscodecs DLL either */
178 ULARGE_INTEGER libNewSize)
179{
180 TRACE("(%p, %s)\n", iface, wine_dbgstr_longlong(libNewSize.QuadPart));
181 return E_NOTIMPL;
182}
183
184/* CopyTo isn't implemented in the native windowscodecs DLL either */
186 IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
187{
188 TRACE("(%p, %p, %s, %p, %p)\n", iface, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
189 return E_NOTIMPL;
190}
191
193 DWORD grfCommitFlags)
194{
195 TRACE("(%p, %#lx)\n", iface, grfCommitFlags);
196 return S_OK;
197}
198
199/* Revert isn't implemented in the native windowscodecs DLL either */
201{
202 TRACE("(%p)\n", iface);
203 return E_NOTIMPL;
204}
205
206/* LockRegion isn't implemented in the native windowscodecs DLL either */
208 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
209{
210 TRACE("(%p, %s, %s, %ld)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
211 wine_dbgstr_longlong(cb.QuadPart), dwLockType);
212 return E_NOTIMPL;
213}
214
215/* UnlockRegion isn't implemented in the native windowscodecs DLL either */
217 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
218{
219 TRACE("(%p, %s, %s, %ld)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
220 wine_dbgstr_longlong(cb.QuadPart), dwLockType);
221 return E_NOTIMPL;
222}
223
225 STATSTG *pstatstg, DWORD grfStatFlag)
226{
228 TRACE("(%p, %p, %#lx)\n", This, pstatstg, grfStatFlag);
229
230 if (!pstatstg) return E_INVALIDARG;
231
232 ZeroMemory(pstatstg, sizeof(STATSTG));
233 pstatstg->type = STGTY_STREAM;
234 pstatstg->cbSize.QuadPart = This->dwMemsize;
235
236 return S_OK;
237}
238
239/* Clone isn't implemented in the native windowscodecs DLL either */
241 IStream **ppstm)
242{
243 TRACE("(%p, %p)\n", iface, ppstm);
244 return E_NOTIMPL;
245}
246
247
248static const IStreamVtbl StreamOnMemory_Vtbl =
249{
250 /*** IUnknown methods ***/
254 /*** ISequentialStream methods ***/
257 /*** IStream methods ***/
267};
268
269/******************************************
270 * StreamOnFileHandle implementation (internal)
271 *
272 */
273typedef struct StreamOnFileHandle {
276
278 void *mem;
281
283{
284 return CONTAINING_RECORD(iface, StreamOnFileHandle, IStream_iface);
285}
286
288 REFIID iid, void **ppv)
289{
290 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
291
292 if (!ppv) return E_INVALIDARG;
293
294 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IStream, iid) ||
295 IsEqualIID(&IID_ISequentialStream, iid))
296 {
297 *ppv = iface;
298 IUnknown_AddRef((IUnknown*)*ppv);
299 return S_OK;
300 }
301 else
302 {
303 *ppv = NULL;
304 return E_NOINTERFACE;
305 }
306}
307
309{
312
313 TRACE("(%p) refcount=%lu\n", iface, ref);
314
315 return ref;
316}
317
319{
322
323 TRACE("(%p) refcount=%lu\n", iface, ref);
324
325 if (ref == 0) {
326 IWICStream_Release(This->stream);
327 UnmapViewOfFile(This->mem);
328 CloseHandle(This->map);
329 free(This);
330 }
331 return ref;
332}
333
335 void *pv, ULONG cb, ULONG *pcbRead)
336{
338 TRACE("(%p, %p, %lu, %p)\n", This, pv, cb, pcbRead);
339
340 return IWICStream_Read(This->stream, pv, cb, pcbRead);
341}
342
344 void const *pv, ULONG cb, ULONG *pcbWritten)
345{
346 ERR("(%p, %p, %lu, %p)\n", iface, pv, cb, pcbWritten);
348}
349
351 LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
352{
354 TRACE("(%p, %s, %ld, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
355
356 return IWICStream_Seek(This->stream, dlibMove, dwOrigin, plibNewPosition);
357}
358
360 ULARGE_INTEGER libNewSize)
361{
362 TRACE("(%p, %s)\n", iface, wine_dbgstr_longlong(libNewSize.QuadPart));
363 return E_NOTIMPL;
364}
365
367 IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
368{
369 TRACE("(%p, %p, %s, %p, %p)\n", iface, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
370 return E_NOTIMPL;
371}
372
374 DWORD grfCommitFlags)
375{
376 TRACE("(%p, %#lx)\n", iface, grfCommitFlags);
377 return S_OK;
378}
379
381{
382 TRACE("(%p)\n", iface);
383 return E_NOTIMPL;
384}
385
387 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
388{
389 TRACE("(%p, %s, %s, %ld)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
390 wine_dbgstr_longlong(cb.QuadPart), dwLockType);
391 return E_NOTIMPL;
392}
393
395 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
396{
397 TRACE("(%p, %s, %s, %ld)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
398 wine_dbgstr_longlong(cb.QuadPart), dwLockType);
399 return E_NOTIMPL;
400}
401
403 STATSTG *pstatstg, DWORD grfStatFlag)
404{
406 TRACE("(%p, %p, %#lx)\n", This, pstatstg, grfStatFlag);
407
408 return IWICStream_Stat(This->stream, pstatstg, grfStatFlag);
409}
410
412 IStream **ppstm)
413{
414 TRACE("(%p, %p)\n", iface, ppstm);
415 return E_NOTIMPL;
416}
417
418static const IStreamVtbl StreamOnFileHandle_Vtbl =
419{
420 /*** IUnknown methods ***/
424 /*** ISequentialStream methods ***/
427 /*** IStream methods ***/
437};
438
439/******************************************
440 * StreamOnStreamRange implementation
441 *
442 * Used by IWICStream_InitializeFromIStreamRegion
443 *
444 */
445typedef struct StreamOnStreamRange {
448
453
456
458{
459 return CONTAINING_RECORD(iface, StreamOnStreamRange, IStream_iface);
460}
461
463 REFIID iid, void **ppv)
464{
465 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
466
467 if (!ppv) return E_INVALIDARG;
468
469 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IStream, iid) ||
470 IsEqualIID(&IID_ISequentialStream, iid))
471 {
472 *ppv = iface;
473 IUnknown_AddRef((IUnknown*)*ppv);
474 return S_OK;
475 }
476 else
477 {
478 *ppv = NULL;
479 return E_NOINTERFACE;
480 }
481}
482
484{
487
488 TRACE("(%p) refcount=%lu\n", iface, ref);
489
490 return ref;
491}
492
494{
497
498 TRACE("(%p) refcount=%lu\n", iface, ref);
499
500 if (ref == 0) {
501 This->lock.DebugInfo->Spare[0] = 0;
503 IStream_Release(This->stream);
504 free(This);
505 }
506 return ref;
507}
508
510 void *pv, ULONG cb, ULONG *pcbRead)
511{
513 ULONG uBytesRead=0;
514 HRESULT hr;
515 ULARGE_INTEGER OldPosition;
516 LARGE_INTEGER SetPosition;
517
518 TRACE("(%p, %p, %lu, %p)\n", This, pv, cb, pcbRead);
519
520 if (!pv) return E_INVALIDARG;
521
523 SetPosition.QuadPart = 0;
524 hr = IStream_Seek(This->stream, SetPosition, STREAM_SEEK_CUR, &OldPosition);
525 if (SUCCEEDED(hr))
526 {
527 SetPosition.QuadPart = This->pos.QuadPart + This->offset.QuadPart;
528 hr = IStream_Seek(This->stream, SetPosition, STREAM_SEEK_SET, NULL);
529 }
530 if (SUCCEEDED(hr))
531 {
532 if (This->pos.QuadPart + cb > This->max_size.QuadPart)
533 {
534 /* This would read past the end of the stream. */
535 if (This->pos.QuadPart > This->max_size.QuadPart)
536 cb = 0;
537 else
538 cb = This->max_size.QuadPart - This->pos.QuadPart;
539 }
540 hr = IStream_Read(This->stream, pv, cb, &uBytesRead);
541 SetPosition.QuadPart = OldPosition.QuadPart;
542 IStream_Seek(This->stream, SetPosition, STREAM_SEEK_SET, NULL);
543 }
544 if (SUCCEEDED(hr))
545 This->pos.QuadPart += uBytesRead;
547
548 if (SUCCEEDED(hr) && pcbRead) *pcbRead = uBytesRead;
549
550 return hr;
551}
552
554 void const *pv, ULONG cb, ULONG *pcbWritten)
555{
557 HRESULT hr;
558 ULARGE_INTEGER OldPosition;
559 LARGE_INTEGER SetPosition;
560 ULONG uBytesWritten=0;
561 TRACE("(%p, %p, %lu, %p)\n", This, pv, cb, pcbWritten);
562
563 if (!pv) return E_INVALIDARG;
564
566 SetPosition.QuadPart = 0;
567 hr = IStream_Seek(This->stream, SetPosition, STREAM_SEEK_CUR, &OldPosition);
568 if (SUCCEEDED(hr))
569 {
570 SetPosition.QuadPart = This->pos.QuadPart + This->offset.QuadPart;
571 hr = IStream_Seek(This->stream, SetPosition, STREAM_SEEK_SET, NULL);
572 }
573 if (SUCCEEDED(hr))
574 {
575 if (This->pos.QuadPart + cb > This->max_size.QuadPart)
576 {
577 /* This would read past the end of the stream. */
578 if (This->pos.QuadPart > This->max_size.QuadPart)
579 cb = 0;
580 else
581 cb = This->max_size.QuadPart - This->pos.QuadPart;
582 }
583 hr = IStream_Write(This->stream, pv, cb, &uBytesWritten);
584 SetPosition.QuadPart = OldPosition.QuadPart;
585 IStream_Seek(This->stream, SetPosition, STREAM_SEEK_SET, NULL);
586 }
587 if (SUCCEEDED(hr))
588 This->pos.QuadPart += uBytesWritten;
590
591 if (SUCCEEDED(hr) && pcbWritten) *pcbWritten = uBytesWritten;
592
593 return hr;
594}
595
597 LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
598{
600 ULARGE_INTEGER NewPosition, actual_size;
602 STATSTG statstg;
603 TRACE("(%p, %s, %ld, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
604
606 actual_size = This->max_size;
607 if (dwOrigin == STREAM_SEEK_SET)
608 NewPosition.QuadPart = dlibMove.QuadPart;
609 else if (dwOrigin == STREAM_SEEK_CUR)
610 NewPosition.QuadPart = This->pos.QuadPart + dlibMove.QuadPart;
611 else if (dwOrigin == STREAM_SEEK_END)
612 {
613 hr = IStream_Stat(This->stream, &statstg, STATFLAG_NONAME);
614 if (SUCCEEDED(hr))
615 {
616 if (This->max_size.QuadPart + This->offset.QuadPart > statstg.cbSize.QuadPart)
617 actual_size.QuadPart = statstg.cbSize.QuadPart - This->offset.QuadPart;
618 NewPosition.QuadPart = dlibMove.QuadPart + actual_size.QuadPart;
619 }
620 }
621 else hr = E_INVALIDARG;
622
623 if (SUCCEEDED(hr) && (NewPosition.u.HighPart != 0 || NewPosition.QuadPart > actual_size.QuadPart))
625
626 if (SUCCEEDED(hr)) {
627 This->pos.QuadPart = NewPosition.QuadPart;
628
629 if(plibNewPosition) plibNewPosition->QuadPart = This->pos.QuadPart;
630 }
632
633 return hr;
634}
635
636/* SetSize isn't implemented in the native windowscodecs DLL either */
638 ULARGE_INTEGER libNewSize)
639{
640 TRACE("(%p, %s)\n", iface, wine_dbgstr_longlong(libNewSize.QuadPart));
641 return E_NOTIMPL;
642}
643
644/* CopyTo isn't implemented in the native windowscodecs DLL either */
646 IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
647{
648 TRACE("(%p, %p, %s, %p, %p)\n", iface, pstm, wine_dbgstr_longlong(cb.QuadPart),
649 pcbRead, pcbWritten);
650 return E_NOTIMPL;
651}
652
653/* Commit isn't implemented in the native windowscodecs DLL either */
655 DWORD grfCommitFlags)
656{
658 TRACE("(%p, %#lx)\n", This, grfCommitFlags);
659 return IStream_Commit(This->stream, grfCommitFlags);
660}
661
662/* Revert isn't implemented in the native windowscodecs DLL either */
664{
665 TRACE("(%p)\n", iface);
666 return E_NOTIMPL;
667}
668
669/* LockRegion isn't implemented in the native windowscodecs DLL either */
671 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
672{
673 TRACE("(%p, %s, %s, %ld)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
674 wine_dbgstr_longlong(cb.QuadPart), dwLockType);
675 return E_NOTIMPL;
676}
677
678/* UnlockRegion isn't implemented in the native windowscodecs DLL either */
680 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
681{
682 TRACE("(%p, %s, %s, %ld)\n", iface, wine_dbgstr_longlong(libOffset.QuadPart),
683 wine_dbgstr_longlong(cb.QuadPart), dwLockType);
684 return E_NOTIMPL;
685}
686
688 STATSTG *pstatstg, DWORD grfStatFlag)
689{
691 HRESULT hr;
692 TRACE("(%p, %p, %#lx)\n", This, pstatstg, grfStatFlag);
693
694 if (!pstatstg) return E_INVALIDARG;
695
697 hr = IStream_Stat(This->stream, pstatstg, grfStatFlag);
698 if (SUCCEEDED(hr))
699 {
700 pstatstg->cbSize.QuadPart -= This->offset.QuadPart;
701 if (This->max_size.QuadPart < pstatstg->cbSize.QuadPart)
702 pstatstg->cbSize.QuadPart = This->max_size.QuadPart;
703 }
704
706
707 return hr;
708}
709
710/* Clone isn't implemented in the native windowscodecs DLL either */
712 IStream **ppstm)
713{
714 TRACE("(%p, %p)\n", iface, ppstm);
715 return E_NOTIMPL;
716}
717
718static const IStreamVtbl StreamOnStreamRange_Vtbl =
719{
720 /*** IUnknown methods ***/
724 /*** ISequentialStream methods ***/
727 /*** IStream methods ***/
737};
738
739
740/******************************************
741 * IWICStream implementation
742 *
743 */
744typedef struct IWICStreamImpl
745{
748
751
753{
754 return CONTAINING_RECORD(iface, IWICStreamImpl, IWICStream_iface);
755}
756
758 REFIID iid, void **ppv)
759{
761 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
762
763 if (!ppv) return E_INVALIDARG;
764
765 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IStream, iid) ||
766 IsEqualIID(&IID_ISequentialStream, iid) || IsEqualIID(&IID_IWICStream, iid))
767 {
768 *ppv = &This->IWICStream_iface;
769 IUnknown_AddRef((IUnknown*)*ppv);
770 return S_OK;
771 }
772 else
773 {
774 *ppv = NULL;
775 return E_NOINTERFACE;
776 }
777}
778
780{
783
784 TRACE("(%p) refcount=%lu\n", iface, ref);
785
786 return ref;
787}
788
790{
793
794 TRACE("(%p) refcount=%lu\n", iface, ref);
795
796 if (ref == 0) {
797 if (This->pStream) IStream_Release(This->pStream);
798 free(This);
799 }
800 return ref;
801}
802
804 void *pv, ULONG cb, ULONG *pcbRead)
805{
807 TRACE("(%p, %p, %lu, %p)\n", This, pv, cb, pcbRead);
808
809 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
810 return IStream_Read(This->pStream, pv, cb, pcbRead);
811}
812
814 void const *pv, ULONG cb, ULONG *pcbWritten)
815{
817 TRACE("(%p, %p, %lu, %p)\n", This, pv, cb, pcbWritten);
818
819 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
820 return IStream_Write(This->pStream, pv, cb, pcbWritten);
821}
822
824 LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
825{
827 TRACE("(%p, %s, %ld, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart),
828 dwOrigin, plibNewPosition);
829
830 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
831 return IStream_Seek(This->pStream, dlibMove, dwOrigin, plibNewPosition);
832}
833
835 ULARGE_INTEGER libNewSize)
836{
838 TRACE("(%p, %s)\n", This, wine_dbgstr_longlong(libNewSize.QuadPart));
839
840 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
841 return IStream_SetSize(This->pStream, libNewSize);
842}
843
845 IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
846{
848 TRACE("(%p, %p, %s, %p, %p)\n", This, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
849
850 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
851 return IStream_CopyTo(This->pStream, pstm, cb, pcbRead, pcbWritten);
852}
853
855 DWORD grfCommitFlags)
856{
858 TRACE("(%p, %#lx)\n", This, grfCommitFlags);
859
860 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
861 return IStream_Commit(This->pStream, grfCommitFlags);
862}
863
865{
867 TRACE("(%p)\n", This);
868
869 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
870 return IStream_Revert(This->pStream);
871}
872
874 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
875{
877 TRACE("(%p, %s, %s, %ld)\n", This, wine_dbgstr_longlong(libOffset.QuadPart),
878 wine_dbgstr_longlong(cb.QuadPart), dwLockType);
879
880 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
881 return IStream_LockRegion(This->pStream, libOffset, cb, dwLockType);
882}
883
885 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
886{
888 TRACE("(%p, %s, %s, %ld)\n", This, wine_dbgstr_longlong(libOffset.QuadPart),
889 wine_dbgstr_longlong(cb.QuadPart), dwLockType);
890
891 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
892 return IStream_UnlockRegion(This->pStream, libOffset, cb, dwLockType);
893}
894
896 STATSTG *pstatstg, DWORD grfStatFlag)
897{
899 TRACE("(%p, %p, %#lx)\n", This, pstatstg, grfStatFlag);
900
901 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
902 return IStream_Stat(This->pStream, pstatstg, grfStatFlag);
903}
904
906 IStream **ppstm)
907{
909 TRACE("(%p, %p)\n", This, ppstm);
910
911 if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED;
912 return IStream_Clone(This->pStream, ppstm);
913}
914
916{
918 HRESULT hr = S_OK;
919
920 TRACE("(%p, %p)\n", iface, stream);
921
922 if (!stream) return E_INVALIDARG;
923 if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
924
925 IStream_AddRef(stream);
926
927 if (InterlockedCompareExchangePointer((void **)&This->pStream, stream, NULL))
928 {
929 /* Some other thread set the stream first. */
930 IStream_Release(stream);
932 }
933
934 return hr;
935}
936
938 LPCWSTR wzFileName, DWORD dwDesiredAccess)
939{
941 HRESULT hr;
942 DWORD dwMode;
944
945 TRACE("(%p, %s, %lu)\n", iface, debugstr_w(wzFileName), dwDesiredAccess);
946
947 if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
948
949 if(dwDesiredAccess & GENERIC_WRITE)
951 else if(dwDesiredAccess & GENERIC_READ)
953 else
954 return E_INVALIDARG;
955
956 hr = SHCreateStreamOnFileW(wzFileName, dwMode, &stream);
957
958 if (SUCCEEDED(hr))
959 {
960 if (InterlockedCompareExchangePointer((void**)&This->pStream, stream, NULL))
961 {
962 /* Some other thread set the stream first. */
963 IStream_Release(stream);
965 }
966 }
967
968 return hr;
969}
970
971/******************************************
972 * IWICStream_InitializeFromMemory
973 *
974 * Initializes the internal IStream object to retrieve its data from a memory chunk.
975 *
976 * PARAMS
977 * pbBuffer [I] pointer to the memory chunk
978 * cbBufferSize [I] number of bytes to use from the memory chunk
979 *
980 * RETURNS
981 * SUCCESS: S_OK
982 * FAILURE: E_INVALIDARG, if pbBuffer is NULL
983 * E_OUTOFMEMORY, if we run out of memory
984 * WINCODEC_ERR_WRONGSTATE, if the IStream object has already been initialized before
985 *
986 */
988 BYTE *pbBuffer, DWORD cbBufferSize)
989{
992 TRACE("(%p, %p, %lu)\n", iface, pbBuffer, cbBufferSize);
993
994 if (!pbBuffer) return E_INVALIDARG;
995 if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
996
997 pObject = malloc(sizeof(StreamOnMemory));
998 if (!pObject) return E_OUTOFMEMORY;
999
1000 pObject->IStream_iface.lpVtbl = &StreamOnMemory_Vtbl;
1001 pObject->ref = 1;
1002 pObject->pbMemory = pbBuffer;
1003 pObject->dwMemsize = cbBufferSize;
1004 pObject->dwCurPos = 0;
1005#ifdef __REACTOS__
1007#else
1009#endif
1010 pObject->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": StreamOnMemory.lock");
1011
1012 if (InterlockedCompareExchangePointer((void**)&This->pStream, pObject, NULL))
1013 {
1014 /* Some other thread set the stream first. */
1015 IStream_Release(&pObject->IStream_iface);
1017 }
1018
1019 return S_OK;
1020}
1021
1023{
1024 *map = NULL;
1026 if (size->u.HighPart)
1027 {
1028 WARN("file too large\n");
1029 return E_FAIL;
1030 }
1031 if (!(*map = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, size->u.LowPart, NULL)))
1032 {
1034 }
1035 if (!(*mem = MapViewOfFile(*map, FILE_MAP_READ, 0, 0, size->u.LowPart)))
1036 {
1037 CloseHandle(*map);
1039 }
1040 return S_OK;
1041}
1042
1044{
1048 HANDLE map;
1049 void *mem;
1051 HRESULT hr;
1052 TRACE("(%p,%p)\n", iface, file);
1053
1054 if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
1055
1056 hr = map_file(file, &map, &mem, &size);
1057 if (FAILED(hr)) return hr;
1058
1060 if (FAILED(hr)) goto error;
1061
1063 if (FAILED(hr)) goto error;
1064
1066 if (!pObject)
1067 {
1068 hr = E_OUTOFMEMORY;
1069 goto error;
1070 }
1071 pObject->IStream_iface.lpVtbl = &StreamOnFileHandle_Vtbl;
1072 pObject->ref = 1;
1073 pObject->map = map;
1074 pObject->mem = mem;
1075 pObject->stream = stream;
1076
1077 if (InterlockedCompareExchangePointer((void**)&This->pStream, pObject, NULL))
1078 {
1079 /* Some other thread set the stream first. */
1080 IStream_Release(&pObject->IStream_iface);
1082 }
1083 return S_OK;
1084
1085error:
1086 if (stream) IWICStream_Release(stream);
1089 return hr;
1090}
1091
1093 IStream *pIStream, ULARGE_INTEGER ulOffset, ULARGE_INTEGER ulMaxSize)
1094{
1097
1098 TRACE("(%p,%p,%s,%s)\n", iface, pIStream, wine_dbgstr_longlong(ulOffset.QuadPart),
1099 wine_dbgstr_longlong(ulMaxSize.QuadPart));
1100
1101 if (!pIStream) return E_INVALIDARG;
1102 if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
1103
1105 if (!pObject) return E_OUTOFMEMORY;
1106
1107 pObject->IStream_iface.lpVtbl = &StreamOnStreamRange_Vtbl;
1108 pObject->ref = 1;
1109 IStream_AddRef(pIStream);
1110 pObject->stream = pIStream;
1111 pObject->pos.QuadPart = 0;
1112 pObject->offset = ulOffset;
1113 pObject->max_size = ulMaxSize;
1114#ifdef __REACTOS__
1116#else
1118#endif
1119 pObject->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": StreamOnStreamRange.lock");
1120
1121 if (InterlockedCompareExchangePointer((void**)&This->pStream, pObject, NULL))
1122 {
1123 /* Some other thread set the stream first. */
1124 IStream_Release(&pObject->IStream_iface);
1126 }
1127
1128 return S_OK;
1129}
1130
1131
1132static const IWICStreamVtbl WICStream_Vtbl =
1133{
1134 /*** IUnknown methods ***/
1138 /*** ISequentialStream methods ***/
1141 /*** IStream methods ***/
1151 /*** IWICStream methods ***/
1156};
1157
1159{
1161
1162 if( !stream ) return E_INVALIDARG;
1163
1164 pObject = malloc(sizeof(IWICStreamImpl));
1165 if( !pObject ) {
1166 *stream = NULL;
1167 return E_OUTOFMEMORY;
1168 }
1169
1170 pObject->IWICStream_iface.lpVtbl = &WICStream_Vtbl;
1171 pObject->ref = 1;
1172 pObject->pStream = NULL;
1173
1174 *stream = &pObject->IWICStream_iface;
1175
1176 return S_OK;
1177}
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define WARN(fmt,...)
Definition: precomp.h:61
#define ERR(fmt,...)
Definition: precomp.h:57
const GUID IID_IUnknown
Definition: _map.h:48
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define NULL
Definition: types.h:112
#define CloseHandle
Definition: compat.h:739
#define PAGE_READONLY
Definition: compat.h:138
#define UnmapViewOfFile
Definition: compat.h:746
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:744
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define GENERIC_READ
Definition: compat.h:135
#define FILE_MAP_READ
Definition: compat.h:776
#define GetFileSizeEx
Definition: compat.h:757
#define MapViewOfFile
Definition: compat.h:745
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
BOOL WINAPI InitializeCriticalSectionEx(OUT LPCRITICAL_SECTION lpCriticalSection, IN DWORD dwSpinCount, IN DWORD flags)
Definition: sync.c:107
HRESULT WINAPI SHCreateStreamOnFileW(LPCWSTR lpszPath, DWORD dwMode, IStream **lppStream)
Definition: istream.c:484
static HRESULT WINAPI StreamOnMemory_Write(IStream *iface, void const *pv, ULONG cb, ULONG *pcbWritten)
Definition: stream.c:120
static HRESULT WINAPI IWICStreamImpl_Revert(IWICStream *iface)
Definition: stream.c:864
static HRESULT WINAPI StreamOnStreamRange_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
Definition: stream.c:637
static ULONG WINAPI IWICStreamImpl_Release(IWICStream *iface)
Definition: stream.c:789
static HRESULT WINAPI IWICStreamImpl_InitializeFromIStreamRegion(IWICStream *iface, IStream *pIStream, ULARGE_INTEGER ulOffset, ULARGE_INTEGER ulMaxSize)
Definition: stream.c:1092
static StreamOnMemory * StreamOnMemory_from_IStream(IStream *iface)
Definition: stream.c:48
static HRESULT WINAPI StreamOnFileHandle_Revert(IStream *iface)
Definition: stream.c:380
static HRESULT WINAPI StreamOnStreamRange_Seek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
Definition: stream.c:596
static HRESULT WINAPI StreamOnFileHandle_Clone(IStream *iface, IStream **ppstm)
Definition: stream.c:411
static ULONG WINAPI IWICStreamImpl_AddRef(IWICStream *iface)
Definition: stream.c:779
static const IStreamVtbl StreamOnStreamRange_Vtbl
Definition: stream.c:718
static HRESULT WINAPI StreamOnMemory_UnlockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: stream.c:216
static HRESULT WINAPI IWICStreamImpl_Seek(IWICStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
Definition: stream.c:823
static HRESULT WINAPI IWICStreamImpl_InitializeFromFilename(IWICStream *iface, LPCWSTR wzFileName, DWORD dwDesiredAccess)
Definition: stream.c:937
static HRESULT WINAPI StreamOnMemory_CopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
Definition: stream.c:185
static const IStreamVtbl StreamOnMemory_Vtbl
Definition: stream.c:248
static HRESULT WINAPI StreamOnFileHandle_Read(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: stream.c:334
static StreamOnFileHandle * StreamOnFileHandle_from_IStream(IStream *iface)
Definition: stream.c:282
static HRESULT WINAPI StreamOnMemory_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
Definition: stream.c:177
static HRESULT WINAPI StreamOnMemory_QueryInterface(IStream *iface, REFIID iid, void **ppv)
Definition: stream.c:53
static HRESULT WINAPI StreamOnFileHandle_Write(IStream *iface, void const *pv, ULONG cb, ULONG *pcbWritten)
Definition: stream.c:343
static HRESULT WINAPI StreamOnFileHandle_Seek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
Definition: stream.c:350
static StreamOnStreamRange * StreamOnStreamRange_from_IStream(IStream *iface)
Definition: stream.c:457
static HRESULT WINAPI StreamOnMemory_Clone(IStream *iface, IStream **ppstm)
Definition: stream.c:240
static HRESULT WINAPI IWICStreamImpl_Stat(IWICStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
Definition: stream.c:895
static HRESULT WINAPI IWICStreamImpl_Write(IWICStream *iface, void const *pv, ULONG cb, ULONG *pcbWritten)
Definition: stream.c:813
static HRESULT WINAPI StreamOnStreamRange_Write(IStream *iface, void const *pv, ULONG cb, ULONG *pcbWritten)
Definition: stream.c:553
static ULONG WINAPI StreamOnStreamRange_AddRef(IStream *iface)
Definition: stream.c:483
static HRESULT WINAPI StreamOnStreamRange_Commit(IStream *iface, DWORD grfCommitFlags)
Definition: stream.c:654
static HRESULT WINAPI StreamOnMemory_Stat(IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
Definition: stream.c:224
static HRESULT WINAPI IWICStreamImpl_SetSize(IWICStream *iface, ULARGE_INTEGER libNewSize)
Definition: stream.c:834
HRESULT stream_initialize_from_filehandle(IWICStream *iface, HANDLE file)
Definition: stream.c:1043
static HRESULT WINAPI StreamOnStreamRange_Revert(IStream *iface)
Definition: stream.c:663
static HRESULT WINAPI IWICStreamImpl_Commit(IWICStream *iface, DWORD grfCommitFlags)
Definition: stream.c:854
static ULONG WINAPI StreamOnFileHandle_Release(IStream *iface)
Definition: stream.c:318
static HRESULT WINAPI StreamOnFileHandle_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
Definition: stream.c:359
static HRESULT WINAPI StreamOnStreamRange_UnlockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: stream.c:679
static HRESULT WINAPI StreamOnStreamRange_Read(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: stream.c:509
static HRESULT WINAPI IWICStreamImpl_CopyTo(IWICStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
Definition: stream.c:844
static HRESULT map_file(HANDLE file, HANDLE *map, void **mem, LARGE_INTEGER *size)
Definition: stream.c:1022
static HRESULT WINAPI StreamOnFileHandle_Commit(IStream *iface, DWORD grfCommitFlags)
Definition: stream.c:373
static HRESULT WINAPI StreamOnMemory_Read(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: stream.c:99
static HRESULT WINAPI StreamOnMemory_Seek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
Definition: stream.c:145
static HRESULT WINAPI IWICStreamImpl_Clone(IWICStream *iface, IStream **ppstm)
Definition: stream.c:905
static HRESULT WINAPI StreamOnFileHandle_Stat(IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
Definition: stream.c:402
static HRESULT WINAPI StreamOnStreamRange_LockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: stream.c:670
static HRESULT WINAPI StreamOnMemory_Revert(IStream *iface)
Definition: stream.c:200
static HRESULT WINAPI StreamOnFileHandle_LockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: stream.c:386
static HRESULT WINAPI IWICStreamImpl_Read(IWICStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: stream.c:803
static const IStreamVtbl StreamOnFileHandle_Vtbl
Definition: stream.c:418
static HRESULT WINAPI StreamOnFileHandle_UnlockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: stream.c:394
HRESULT StreamImpl_Create(IWICStream **stream)
Definition: stream.c:1158
static HRESULT WINAPI StreamOnFileHandle_QueryInterface(IStream *iface, REFIID iid, void **ppv)
Definition: stream.c:287
static HRESULT WINAPI IWICStreamImpl_QueryInterface(IWICStream *iface, REFIID iid, void **ppv)
Definition: stream.c:757
static HRESULT WINAPI IWICStreamImpl_InitializeFromIStream(IWICStream *iface, IStream *stream)
Definition: stream.c:915
static HRESULT WINAPI StreamOnStreamRange_Clone(IStream *iface, IStream **ppstm)
Definition: stream.c:711
static ULONG WINAPI StreamOnMemory_Release(IStream *iface)
Definition: stream.c:84
static HRESULT WINAPI IWICStreamImpl_LockRegion(IWICStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: stream.c:873
static HRESULT WINAPI StreamOnStreamRange_QueryInterface(IStream *iface, REFIID iid, void **ppv)
Definition: stream.c:462
static HRESULT WINAPI StreamOnMemory_Commit(IStream *iface, DWORD grfCommitFlags)
Definition: stream.c:192
static IWICStreamImpl * impl_from_IWICStream(IWICStream *iface)
Definition: stream.c:752
static ULONG WINAPI StreamOnStreamRange_Release(IStream *iface)
Definition: stream.c:493
static HRESULT WINAPI StreamOnMemory_LockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: stream.c:207
static ULONG WINAPI StreamOnFileHandle_AddRef(IStream *iface)
Definition: stream.c:308
static HRESULT WINAPI StreamOnStreamRange_Stat(IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
Definition: stream.c:687
static const IWICStreamVtbl WICStream_Vtbl
Definition: stream.c:1132
static ULONG WINAPI StreamOnMemory_AddRef(IStream *iface)
Definition: stream.c:74
static HRESULT WINAPI IWICStreamImpl_UnlockRegion(IWICStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: stream.c:884
static HRESULT WINAPI StreamOnFileHandle_CopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
Definition: stream.c:366
static HRESULT WINAPI IWICStreamImpl_InitializeFromMemory(IWICStream *iface, BYTE *pbBuffer, DWORD cbBufferSize)
Definition: stream.c:987
static HRESULT WINAPI StreamOnStreamRange_CopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
Definition: stream.c:645
unsigned long DWORD
Definition: ntddk_ex.h:95
FxObject * pObject
GLsizeiptr size
Definition: glext.h:5919
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
#define error(str)
Definition: mkdosfs.c:1605
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
#define min(a, b)
Definition: monoChain.cc:55
#define GENERIC_WRITE
Definition: nt_native.h:90
#define STGM_CREATE
Definition: objbase.h:926
#define STGM_FAILIFTHERE
Definition: objbase.h:928
#define STGM_SHARE_DENY_WRITE
Definition: objbase.h:922
#define STGM_WRITE
Definition: objbase.h:918
#define STGM_READ
Definition: objbase.h:917
long LONG
Definition: pedump.c:60
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
IStream * pStream
Definition: stream.c:749
IWICStream IWICStream_iface
Definition: stream.c:746
IWICStream * stream
Definition: stream.c:279
IStream IStream_iface
Definition: stream.c:274
BYTE * pbMemory
Definition: stream.c:41
IStream IStream_iface
Definition: stream.c:38
DWORD dwCurPos
Definition: stream.c:43
DWORD dwMemsize
Definition: stream.c:42
CRITICAL_SECTION lock
Definition: stream.c:45
LONG ref
Definition: stream.c:39
IStream IStream_iface
Definition: stream.c:446
ULARGE_INTEGER offset
Definition: stream.c:451
CRITICAL_SECTION lock
Definition: stream.c:454
ULARGE_INTEGER pos
Definition: stream.c:450
ULARGE_INTEGER max_size
Definition: stream.c:452
IStream * stream
Definition: stream.c:449
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
struct _ULARGE_INTEGER::@4227 u
Definition: fci.c:127
Definition: mem.c:349
Definition: send.c:48
Definition: parse.h:23
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define DWORD_PTR
Definition: treelist.c:76
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
struct _LARGE_INTEGER::@2348 u
LONGLONG QuadPart
Definition: typedefs.h:114
#define ZeroMemory
Definition: winbase.h:1737
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
#define WINAPI
Definition: msvc.h:6
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3281
#define WINCODEC_ERR_NOTINITIALIZED
Definition: winerror.h:3285
#define E_NOINTERFACE
Definition: winerror.h:2364
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define ERROR_ARITHMETIC_OVERFLOW
Definition: winerror.h:351
#define STG_E_MEDIUMFULL
Definition: winerror.h:2581
#define WINCODEC_ERR_VALUEOUTOFRANGE
Definition: winerror.h:3282
#define RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO
Definition: winnt_old.h:1118
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193