return hr;
}
-static IWICBitmapDecoder *find_decoder(IStream *pIStream, const GUID *pguidVendor,
- WICDecodeOptions metadataOptions)
+static HRESULT find_decoder(IStream *pIStream, const GUID *pguidVendor,
+ WICDecodeOptions metadataOptions, IWICBitmapDecoder **decoder)
{
IEnumUnknown *enumdecoders;
IUnknown *unkdecoderinfo;
IWICBitmapDecoderInfo *decoderinfo;
- IWICBitmapDecoder *decoder = NULL;
GUID vendor;
HRESULT res;
ULONG num_fetched;
BOOL matches;
+ *decoder = NULL;
+
res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
- if (FAILED(res)) return NULL;
+ if (FAILED(res)) return res;
- while (!decoder)
+ while (!*decoder)
{
res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
if (SUCCEEDED(res) && matches)
{
- res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
+ res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, decoder);
/* FIXME: should use QueryCapability to choose a decoder */
if (SUCCEEDED(res))
{
- res = IWICBitmapDecoder_Initialize(decoder, pIStream, metadataOptions);
+ res = IWICBitmapDecoder_Initialize(*decoder, pIStream, metadataOptions);
if (FAILED(res))
{
- IWICBitmapDecoder_Release(decoder);
- decoder = NULL;
+ IWICBitmapDecoder_Release(*decoder);
+ IWICBitmapDecoderInfo_Release(decoderinfo);
+ IUnknown_Release(unkdecoderinfo);
+ *decoder = NULL;
+ return res;
}
}
}
IEnumUnknown_Release(enumdecoders);
- return decoder;
+ return WINCODEC_ERR_COMPONENTNOTFOUND;
}
static HRESULT WINAPI ComponentFactory_CreateDecoderFromStream(
metadataOptions, ppIDecoder);
if (pguidVendor)
- decoder = find_decoder(pIStream, pguidVendor, metadataOptions);
+ res = find_decoder(pIStream, pguidVendor, metadataOptions, &decoder);
if (!decoder)
- decoder = find_decoder(pIStream, NULL, metadataOptions);
+ res = find_decoder(pIStream, NULL, metadataOptions, &decoder);
if (decoder)
{
BYTE data[4];
ULONG bytesread;
- WARN("failed to load from a stream\n");
+ WARN("failed to load from a stream %#x\n", res);
seek.QuadPart = 0;
- res = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
- if (SUCCEEDED(res))
- res = IStream_Read(pIStream, data, 4, &bytesread);
- if (SUCCEEDED(res))
- WARN("first %i bytes of stream=%x %x %x %x\n", bytesread, data[0], data[1], data[2], data[3]);
+ if (IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL) == S_OK)
+ {
+ if (IStream_Read(pIStream, data, 4, &bytesread) == S_OK)
+ WARN("first %i bytes of stream=%x %x %x %x\n", bytesread, data[0], data[1], data[2], data[3]);
+ }
}
*ppIDecoder = NULL;
- return WINCODEC_ERR_COMPONENTNOTFOUND;
+ return res;
}
}
IWICBitmapLock_Release(lock);
}
- if (SUCCEEDED(hr))
- hr = PaletteImpl_Create(&palette);
-
if (SUCCEEDED(hr) && (format_type == WICPixelFormatNumericRepresentationUnspecified ||
format_type == WICPixelFormatNumericRepresentationIndexed))
{
- hr = IWICBitmapSource_CopyPalette(piBitmapSource, palette);
+ hr = PaletteImpl_Create(&palette);
if (SUCCEEDED(hr))
- hr = IWICBitmap_SetPalette(result, palette);
- else
- hr = S_OK;
+ {
+ hr = IWICBitmapSource_CopyPalette(piBitmapSource, palette);
+
+ if (SUCCEEDED(hr))
+ hr = IWICBitmap_SetPalette(result, palette);
+ else
+ hr = S_OK;
- IWICPalette_Release(palette);
+ IWICPalette_Release(palette);
+ }
}
if (SUCCEEDED(hr))
UINT width, UINT height, REFWICPixelFormatGUID format, UINT stride,
UINT size, BYTE *buffer, IWICBitmap **bitmap)
{
+ HRESULT hr;
+
TRACE("(%p,%u,%u,%s,%u,%u,%p,%p\n", iface, width, height,
debugstr_guid(format), stride, size, buffer, bitmap);
if (!stride || !size || !buffer || !bitmap) return E_INVALIDARG;
- return BitmapImpl_Create(width, height, stride, size, buffer, format, WICBitmapCacheOnLoad, bitmap);
+ hr = BitmapImpl_Create(width, height, stride, size, NULL, format, WICBitmapCacheOnLoad, bitmap);
+ if (SUCCEEDED(hr))
+ {
+ IWICBitmapLock *lock;
+
+ hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
+ if (SUCCEEDED(hr))
+ {
+ UINT buffersize;
+ BYTE *data;
+
+ IWICBitmapLock_GetDataPointer(lock, &buffersize, &data);
+ memcpy(data, buffer, buffersize);
+
+ IWICBitmapLock_Release(lock);
+ }
+ else
+ {
+ IWICBitmap_Release(*bitmap);
+ *bitmap = NULL;
+ }
+ }
+ return hr;
}
static BOOL get_16bpp_format(HBITMAP hbm, WICPixelFormatGUID *format)
return E_INVALIDARG;
}
- hr = BitmapImpl_Create(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, 0, NULL, &format, option, bitmap);
+ hr = BitmapImpl_Create(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, 0, NULL, &format, WICBitmapCacheOnLoad, bitmap);
if (hr != S_OK) return hr;
hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
static HRESULT WINAPI ComponentFactory_CreateMetadataReaderFromContainer(IWICComponentFactory *iface,
REFGUID format, const GUID *vendor, DWORD options, IStream *stream, IWICMetadataReader **reader)
{
- FIXME("%p,%s,%s,%x,%p,%p: stub\n", iface, debugstr_guid(format), debugstr_guid(vendor),
+ HRESULT hr;
+ IEnumUnknown *enumreaders;
+ IUnknown *unkreaderinfo;
+ IWICMetadataReaderInfo *readerinfo;
+ IWICPersistStream *wicpersiststream;
+ ULONG num_fetched;
+ GUID decoder_vendor;
+ BOOL matches;
+ LARGE_INTEGER zero;
+
+ TRACE("%p,%s,%s,%x,%p,%p\n", iface, debugstr_guid(format), debugstr_guid(vendor),
options, stream, reader);
- return E_NOTIMPL;
+
+ if (!format || !stream || !reader)
+ return E_INVALIDARG;
+
+ zero.QuadPart = 0;
+
+ hr = CreateComponentEnumerator(WICMetadataReader, WICComponentEnumerateDefault, &enumreaders);
+ if (FAILED(hr)) return hr;
+
+ *reader = NULL;
+
+start:
+ while (!*reader)
+ {
+ hr = IEnumUnknown_Next(enumreaders, 1, &unkreaderinfo, &num_fetched);
+
+ if (hr == S_OK)
+ {
+ hr = IUnknown_QueryInterface(unkreaderinfo, &IID_IWICMetadataReaderInfo, (void**)&readerinfo);
+
+ if (SUCCEEDED(hr))
+ {
+ if (vendor)
+ {
+ hr = IWICMetadataReaderInfo_GetVendorGUID(readerinfo, &decoder_vendor);
+
+ if (FAILED(hr) || !IsEqualIID(vendor, &decoder_vendor))
+ {
+ IWICMetadataReaderInfo_Release(readerinfo);
+ IUnknown_Release(unkreaderinfo);
+ continue;
+ }
+ }
+
+ hr = IWICMetadataReaderInfo_MatchesPattern(readerinfo, format, stream, &matches);
+
+ if (SUCCEEDED(hr) && matches)
+ {
+ hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
+
+ if (SUCCEEDED(hr))
+ hr = IWICMetadataReaderInfo_CreateInstance(readerinfo, reader);
+
+ if (SUCCEEDED(hr))
+ {
+ hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
+
+ if (SUCCEEDED(hr))
+ {
+ hr = IWICPersistStream_LoadEx(wicpersiststream,
+ stream, vendor, options & WICPersistOptionMask);
+
+ IWICPersistStream_Release(wicpersiststream);
+ }
+
+ if (FAILED(hr))
+ {
+ IWICMetadataReader_Release(*reader);
+ *reader = NULL;
+ }
+ }
+ }
+
+ IUnknown_Release(readerinfo);
+ }
+
+ IUnknown_Release(unkreaderinfo);
+ }
+ else
+ break;
+ }
+
+ if (!*reader && vendor)
+ {
+ vendor = NULL;
+ IEnumUnknown_Reset(enumreaders);
+ goto start;
+ }
+
+ IEnumUnknown_Release(enumreaders);
+
+ if (!*reader && !(options & WICMetadataCreationFailUnknown))
+ {
+ hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
+
+ if (SUCCEEDED(hr))
+ hr = UnknownMetadataReader_CreateInstance(&IID_IWICMetadataReader, (void**)reader);
+
+ if (SUCCEEDED(hr))
+ {
+ hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
+
+ if (SUCCEEDED(hr))
+ {
+ hr = IWICPersistStream_LoadEx(wicpersiststream, stream, NULL, options & WICPersistOptionMask);
+
+ IWICPersistStream_Release(wicpersiststream);
+ }
+
+ if (FAILED(hr))
+ {
+ IWICMetadataReader_Release(*reader);
+ *reader = NULL;
+ }
+ }
+ }
+
+ if (*reader)
+ return S_OK;
+ else
+ return WINCODEC_ERR_COMPONENTNOTFOUND;
}
static HRESULT WINAPI ComponentFactory_CreateMetadataWriter(IWICComponentFactory *iface,
static HRESULT WINAPI ComponentFactory_CreateQueryReaderFromBlockReader(IWICComponentFactory *iface,
IWICMetadataBlockReader *block_reader, IWICMetadataQueryReader **query_reader)
{
- FIXME("%p,%p,%p: stub\n", iface, block_reader, query_reader);
- return E_NOTIMPL;
+ TRACE("%p,%p,%p\n", iface, block_reader, query_reader);
+
+ if (!block_reader || !query_reader)
+ return E_INVALIDARG;
+
+ return MetadataQueryReader_CreateInstance(block_reader, NULL, query_reader);
}
static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromBlockWriter(IWICComponentFactory *iface,
return ret;
}
+
+HRESULT WINAPI WICCreateBitmapFromSectionEx(UINT width, UINT height,
+ REFWICPixelFormatGUID format, HANDLE section, UINT stride,
+ UINT offset, WICSectionAccessLevel wicaccess, IWICBitmap **bitmap)
+{
+ DWORD access;
+ void *buffer;
+ HRESULT hr;
+
+ TRACE("%u,%u,%s,%p,%u,%#x,%#x,%p\n", width, height, debugstr_guid(format),
+ section, stride, offset, wicaccess, bitmap);
+
+ if (!width || !height || !section || !bitmap) return E_INVALIDARG;
+
+ switch (wicaccess)
+ {
+ case WICSectionAccessLevelReadWrite:
+ access = FILE_MAP_READ | FILE_MAP_WRITE;
+ break;
+
+ case WICSectionAccessLevelRead:
+ access = FILE_MAP_READ;
+ break;
+
+ default:
+ FIXME("unsupported access %#x\n", wicaccess);
+ return E_INVALIDARG;
+ }
+
+ buffer = MapViewOfFile(section, access, 0, offset, 0);
+ if (!buffer) return HRESULT_FROM_WIN32(GetLastError());
+
+ hr = BitmapImpl_Create(width, height, stride, 0, buffer, format, WICBitmapCacheOnLoad, bitmap);
+ if (FAILED(hr)) UnmapViewOfFile(buffer);
+ return hr;
+}
+
+HRESULT WINAPI WICCreateBitmapFromSection(UINT width, UINT height,
+ REFWICPixelFormatGUID format, HANDLE section,
+ UINT stride, UINT offset, IWICBitmap **bitmap)
+{
+ TRACE("%u,%u,%s,%p,%u,%u,%p\n", width, height, debugstr_guid(format),
+ section, stride, offset, bitmap);
+
+ return WICCreateBitmapFromSectionEx(width, height, format, section,
+ stride, offset, WICSectionAccessLevelRead, bitmap);
+}
projects / reactos.git / blobdiff