dlls/windowscodecs/metadatahandler.c

   1 /*
   2  * Copyright 2012 Vincent Povirk for CodeWeavers
   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 "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28 #include "wincodec.h"
  29 #include "wincodecsdk.h"
  30
  31 #include "wincodecs_private.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  36
  37 typedef struct MetadataHandler {
  38     IWICMetadataWriter IWICMetadataWriter_iface;
  39     LONG ref;
  40     IWICPersistStream IWICPersistStream_iface;
  41     const MetadataHandlerVtbl *vtable;
  42 } MetadataHandler;
  43
  44 static inline MetadataHandler *impl_from_IWICMetadataWriter(IWICMetadataWriter *iface)
  45 {
  46     return CONTAINING_RECORD(iface, MetadataHandler, IWICMetadataWriter_iface);
  47 }
  48
  49 static inline MetadataHandler *impl_from_IWICPersistStream(IWICPersistStream *iface)
  50 {
  51     return CONTAINING_RECORD(iface, MetadataHandler, IWICPersistStream_iface);
  52 }
  53
  54 static HRESULT WINAPI MetadataHandler_QueryInterface(IWICMetadataWriter *iface, REFIID iid,
  55     void **ppv)
  56 {
  57     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
  58     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  59
  60     if (!ppv) return E_INVALIDARG;
  61
  62     if (IsEqualIID(&IID_IUnknown, iid) ||
  63         IsEqualIID(&IID_IWICMetadataReader, iid) ||
  64         (IsEqualIID(&IID_IWICMetadataWriter, iid) && This->vtable->is_writer))
  65     {
  66         *ppv = &This->IWICMetadataWriter_iface;
  67     }
  68     else if (IsEqualIID(&IID_IPersist, iid) ||
  69              IsEqualIID(&IID_IPersistStream, iid) ||
  70              IsEqualIID(&IID_IWICPersistStream, iid))
  71     {
  72         *ppv = &This->IWICPersistStream_iface;
  73     }
  74     else
  75     {
  76         *ppv = NULL;
  77         return E_NOINTERFACE;
  78     }
  79
  80     IUnknown_AddRef((IUnknown*)*ppv);
  81     return S_OK;
  82 }
  83
  84 static ULONG WINAPI MetadataHandler_AddRef(IWICMetadataWriter *iface)
  85 {
  86     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
  87     ULONG ref = InterlockedIncrement(&This->ref);
  88
  89     TRACE("(%p) refcount=%u\n", iface, ref);
  90
  91     return ref;
  92 }
  93
  94 static ULONG WINAPI MetadataHandler_Release(IWICMetadataWriter *iface)
  95 {
  96     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
  97     ULONG ref = InterlockedDecrement(&This->ref);
  98
  99     TRACE("(%p) refcount=%u\n", iface, ref);
 100
 101     if (ref == 0)
 102     {
 103         HeapFree(GetProcessHeap(), 0, This);
 104     }
 105
 106     return ref;
 107 }
 108
 109 static HRESULT WINAPI MetadataHandler_GetMetadataFormat(IWICMetadataWriter *iface,
 110     GUID *pguidMetadataFormat)
 111 {
 112     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidMetadataFormat));
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI MetadataHandler_GetMetadataHandlerInfo(IWICMetadataWriter *iface,
 117     IWICMetadataHandlerInfo **ppIHandler)
 118 {
 119     FIXME("(%p,%p): stub\n", iface, ppIHandler);
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI MetadataHandler_GetCount(IWICMetadataWriter *iface,
 124     UINT *pcCount)
 125 {
 126     FIXME("(%p,%p): stub\n", iface, pcCount);
 127     return E_NOTIMPL;
 128 }
 129
 130 static HRESULT WINAPI MetadataHandler_GetValueByIndex(IWICMetadataWriter *iface,
 131     UINT nIndex, PROPVARIANT *pvarSchema, PROPVARIANT *pvarId, PROPVARIANT *pvarValue)
 132 {
 133     FIXME("(%p,%u,%p,%p,%p): stub\n", iface, nIndex, pvarSchema, pvarId, pvarValue);
 134     return E_NOTIMPL;
 135 }
 136
 137 static HRESULT WINAPI MetadataHandler_GetValue(IWICMetadataWriter *iface,
 138     const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId, PROPVARIANT *pvarValue)
 139 {
 140     FIXME("(%p,%p,%p,%p): stub\n", iface, pvarSchema, pvarId, pvarValue);
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT WINAPI MetadataHandler_GetEnumerator(IWICMetadataWriter *iface,
 145     IWICEnumMetadataItem **ppIEnumMetadata)
 146 {
 147     FIXME("(%p,%p): stub\n", iface, ppIEnumMetadata);
 148     return E_NOTIMPL;
 149 }
 150
 151 static HRESULT WINAPI MetadataHandler_SetValue(IWICMetadataWriter *iface,
 152     const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId, const PROPVARIANT *pvarValue)
 153 {
 154     FIXME("(%p,%p,%p,%p): stub\n", iface, pvarSchema, pvarId, pvarValue);
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI MetadataHandler_SetValueByIndex(IWICMetadataWriter *iface,
 159     UINT nIndex, const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId, const PROPVARIANT *pvarValue)
 160 {
 161     FIXME("(%p,%u,%p,%p,%p): stub\n", iface, nIndex, pvarSchema, pvarId, pvarValue);
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI MetadataHandler_RemoveValue(IWICMetadataWriter *iface,
 166     const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId)
 167 {
 168     FIXME("(%p,%p,%p): stub\n", iface, pvarSchema, pvarId);
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI MetadataHandler_RemoveValueByIndex(IWICMetadataWriter *iface,
 173     UINT nIndex)
 174 {
 175     FIXME("(%p,%u): stub\n", iface, nIndex);
 176     return E_NOTIMPL;
 177 }
 178
 179 static const IWICMetadataWriterVtbl MetadataHandler_Vtbl = {
 180     MetadataHandler_QueryInterface,
 181     MetadataHandler_AddRef,
 182     MetadataHandler_Release,
 183     MetadataHandler_GetMetadataFormat,
 184     MetadataHandler_GetMetadataHandlerInfo,
 185     MetadataHandler_GetCount,
 186     MetadataHandler_GetValueByIndex,
 187     MetadataHandler_GetValue,
 188     MetadataHandler_GetEnumerator,
 189     MetadataHandler_SetValue,
 190     MetadataHandler_SetValueByIndex,
 191     MetadataHandler_RemoveValue,
 192     MetadataHandler_RemoveValueByIndex
 193 };
 194
 195 static HRESULT WINAPI MetadataHandler_PersistStream_QueryInterface(IWICPersistStream *iface,
 196     REFIID iid, void **ppv)
 197 {
 198     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 199     return IWICMetadataWriter_QueryInterface(&This->IWICMetadataWriter_iface, iid, ppv);
 200 }
 201
 202 static ULONG WINAPI MetadataHandler_PersistStream_AddRef(IWICPersistStream *iface)
 203 {
 204     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 205     return IWICMetadataWriter_AddRef(&This->IWICMetadataWriter_iface);
 206 }
 207
 208 static ULONG WINAPI MetadataHandler_PersistStream_Release(IWICPersistStream *iface)
 209 {
 210     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 211     return IWICMetadataWriter_Release(&This->IWICMetadataWriter_iface);
 212 }
 213
 214 static HRESULT WINAPI MetadataHandler_GetClassID(IWICPersistStream *iface,
 215     CLSID *pClassID)
 216 {
 217     FIXME("(%p,%p): stub\n", iface, pClassID);
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI MetadataHandler_IsDirty(IWICPersistStream *iface)
 222 {
 223     FIXME("(%p): stub\n", iface);
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI MetadataHandler_Load(IWICPersistStream *iface,
 228     IStream *pStm)
 229 {
 230     FIXME("(%p,%p): stub\n", iface, pStm);
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI MetadataHandler_Save(IWICPersistStream *iface,
 235     IStream *pStm, BOOL fClearDirty)
 236 {
 237     FIXME("(%p,%p,%i): stub\n", iface, pStm, fClearDirty);
 238     return E_NOTIMPL;
 239 }
 240
 241 static HRESULT WINAPI MetadataHandler_GetSizeMax(IWICPersistStream *iface,
 242     ULARGE_INTEGER *pcbSize)
 243 {
 244     FIXME("(%p,%p): stub\n", iface, pcbSize);
 245     return E_NOTIMPL;
 246 }
 247
 248 static HRESULT WINAPI MetadataHandler_LoadEx(IWICPersistStream *iface,
 249     IStream *pIStream, const GUID *pguidPreferredVendor, DWORD dwPersistOptions)
 250 {
 251     FIXME("(%p,%p,%s,%x): stub\n", iface, pIStream, debugstr_guid(pguidPreferredVendor), dwPersistOptions);
 252     return E_NOTIMPL;
 253 }
 254
 255 static HRESULT WINAPI MetadataHandler_SaveEx(IWICPersistStream *iface,
 256     IStream *pIStream, DWORD dwPersistOptions, BOOL fClearDirty)
 257 {
 258     FIXME("(%p,%p,%x,%i): stub\n", iface, pIStream, dwPersistOptions, fClearDirty);
 259     return E_NOTIMPL;
 260 }
 261
 262 static const IWICPersistStreamVtbl MetadataHandler_PersistStream_Vtbl = {
 263     MetadataHandler_PersistStream_QueryInterface,
 264     MetadataHandler_PersistStream_AddRef,
 265     MetadataHandler_PersistStream_Release,
 266     MetadataHandler_GetClassID,
 267     MetadataHandler_IsDirty,
 268     MetadataHandler_Load,
 269     MetadataHandler_Save,
 270     MetadataHandler_GetSizeMax,
 271     MetadataHandler_LoadEx,
 272     MetadataHandler_SaveEx
 273 };
 274
 275 HRESULT MetadataReader_Create(const MetadataHandlerVtbl *vtable, IUnknown *pUnkOuter, REFIID iid, void** ppv)
 276 {
 277     MetadataHandler *This;
 278     HRESULT hr;
 279
 280     TRACE("%s\n", debugstr_guid(vtable->clsid));
 281
 282     *ppv = NULL;
 283
 284     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 285
 286     This = HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandler));
 287     if (!This) return E_OUTOFMEMORY;
 288
 289     This->IWICMetadataWriter_iface.lpVtbl = &MetadataHandler_Vtbl;
 290     This->IWICPersistStream_iface.lpVtbl = &MetadataHandler_PersistStream_Vtbl;
 291     This->ref = 1;
 292     This->vtable = vtable;
 293
 294     hr = IWICMetadataWriter_QueryInterface(&This->IWICMetadataWriter_iface, iid, ppv);
 295
 296     IWICMetadataWriter_Release(&This->IWICMetadataWriter_iface);
 297
 298     return hr;
 299 }
 300
 301 static HRESULT LoadUnknownMetadata(IStream *input, const GUID *preferred_vendor,
 302     DWORD persist_options, MetadataItem **items, DWORD *item_count)
 303 {
 304     FIXME("\n");
 305     return E_NOTIMPL;
 306 }
 307
 308 static const MetadataHandlerVtbl UnknownMetadataReader_Vtbl = {
 309     0,
 310     &CLSID_WICUnknownMetadataReader,
 311     LoadUnknownMetadata
 312 };
 313
 314 HRESULT UnknownMetadataReader_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
 315 {
 316     return MetadataReader_Create(&UnknownMetadataReader_Vtbl, pUnkOuter, iid, ppv);
 317 }