dlls/d3dxof/d3dxof.c

   1 /*
   2  * Implementation of DirectX File Interfaces
   3  *
   4  * Copyright 2004, 2008, 2010 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "d3dxof_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d3dxof);
  24 WINE_DECLARE_DEBUG_CHANNEL(d3dxof_dump);
  25
  26 static const struct IDirectXFileVtbl IDirectXFile_Vtbl;
  27 static const struct IDirectXFileBinaryVtbl IDirectXFileBinary_Vtbl;
  28 static const struct IDirectXFileDataVtbl IDirectXFileData_Vtbl;
  29 static const struct IDirectXFileDataReferenceVtbl IDirectXFileDataReference_Vtbl;
  30 static const struct IDirectXFileEnumObjectVtbl IDirectXFileEnumObject_Vtbl;
  31 static const struct IDirectXFileSaveObjectVtbl IDirectXFileSaveObject_Vtbl;
  32
  33 static HRESULT IDirectXFileDataReferenceImpl_Create(IDirectXFileDataReferenceImpl** ppObj);
  34 static HRESULT IDirectXFileEnumObjectImpl_Create(IDirectXFileEnumObjectImpl** ppObj);
  35 static HRESULT IDirectXFileSaveObjectImpl_Create(IDirectXFileSaveObjectImpl** ppObj);
  36
  37 #define TOKEN_DWORD       41
  38 #define TOKEN_FLOAT       42
  39
  40 HRESULT IDirectXFileImpl_Create(IUnknown* pUnkOuter, LPVOID* ppObj)
  41 {
  42     IDirectXFileImpl* object;
  43
  44     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
  45
  46     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileImpl));
  47     if (!object)
  48         return DXFILEERR_BADALLOC;
  49
  50     object->IDirectXFile_iface.lpVtbl = &IDirectXFile_Vtbl;
  51     object->ref = 1;
  52
  53     /* Reserve first template to handle the case sensitive legacy type indexColor */
  54     object->nb_xtemplates = 1;
  55     strcpy(object->xtemplates[0].name, "indexColor");
  56     object->xtemplates[0].nb_members = 2;
  57     object->xtemplates[0].members[0].type = TOKEN_DWORD;
  58     object->xtemplates[0].members[0].nb_dims = 0;
  59     object->xtemplates[0].members[1].type = TOKEN_FLOAT;
  60     object->xtemplates[0].members[1].nb_dims = 1;
  61     object->xtemplates[0].members[1].dim_fixed[0] = TRUE;
  62     object->xtemplates[0].members[1].dim_value[0] = 4;
  63
  64     *ppObj = &object->IDirectXFile_iface;
  65
  66     return S_OK;
  67 }
  68
  69 static inline IDirectXFileImpl *impl_from_IDirectXFile(IDirectXFile *iface)
  70 {
  71     return CONTAINING_RECORD(iface, IDirectXFileImpl, IDirectXFile_iface);
  72 }
  73
  74 static HRESULT WINAPI IDirectXFileImpl_QueryInterface(IDirectXFile *iface, REFIID riid, void **out)
  75 {
  76     IDirectXFileImpl *object = impl_from_IDirectXFile(iface);
  77
  78     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  79
  80     if (IsEqualGUID(riid, &IID_IUnknown)
  81             || IsEqualGUID(riid, &IID_IDirectXFile))
  82     {
  83         *out = &object->IDirectXFile_iface;
  84     }
  85     else
  86     {
  87         *out = NULL;
  88         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  89         return E_NOINTERFACE;
  90     }
  91
  92     IUnknown_AddRef((IUnknown *)*out);
  93     return S_OK;
  94 }
  95
  96 static ULONG WINAPI IDirectXFileImpl_AddRef(IDirectXFile *iface)
  97 {
  98     IDirectXFileImpl *object = impl_from_IDirectXFile(iface);
  99     ULONG refcount = InterlockedIncrement(&object->ref);
 100
 101     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 102
 103     return refcount;
 104 }
 105
 106 static ULONG WINAPI IDirectXFileImpl_Release(IDirectXFile *iface)
 107 {
 108     IDirectXFileImpl *object = impl_from_IDirectXFile(iface);
 109     ULONG refcount = InterlockedDecrement(&object->ref);
 110
 111     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 112
 113     if (!refcount)
 114         HeapFree(GetProcessHeap(), 0, object);
 115
 116     return refcount;
 117 }
 118
 119 /*** IDirectXFile methods ***/
 120 static HRESULT WINAPI IDirectXFileImpl_CreateEnumObject(IDirectXFile* iface, LPVOID pvSource, DXFILELOADOPTIONS dwLoadOptions, LPDIRECTXFILEENUMOBJECT* ppEnumObj)
 121 {
 122   IDirectXFileImpl *This = impl_from_IDirectXFile(iface);
 123   IDirectXFileEnumObjectImpl* object;
 124   HRESULT hr;
 125   LPBYTE file_buffer;
 126   DWORD file_size;
 127   DWORD bytes_written;
 128
 129   TRACE("iface %p, source %p, load_options %#lx, out %p.\n", iface, pvSource, dwLoadOptions, ppEnumObj);
 130
 131   if (!ppEnumObj)
 132     return DXFILEERR_BADVALUE;
 133
 134   /* Only lowest 4 bits are relevant in DXFILELOADOPTIONS */
 135   dwLoadOptions &= 0xF;
 136
 137   hr = IDirectXFileEnumObjectImpl_Create(&object);
 138   if (FAILED(hr))
 139     return hr;
 140
 141   if (dwLoadOptions == DXFILELOAD_FROMFILE)
 142   {
 143     HANDLE hFile, file_mapping;
 144
 145     TRACE("Open source file '%s'\n", (char*)pvSource);
 146
 147     hFile = CreateFileA(pvSource, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 148     if (hFile == INVALID_HANDLE_VALUE)
 149     {
 150       TRACE("File '%s' not found\n", (char*)pvSource);
 151       return DXFILEERR_FILENOTFOUND;
 152     }
 153
 154     file_size = GetFileSize(hFile, NULL);
 155
 156     file_mapping = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
 157     CloseHandle(hFile);
 158     if (!file_mapping)
 159     {
 160       hr = DXFILEERR_BADFILETYPE;
 161       goto error;
 162     }
 163
 164     object->mapped_memory = MapViewOfFile(file_mapping, FILE_MAP_READ, 0, 0, 0);
 165     CloseHandle(file_mapping);
 166     if (!object->mapped_memory)
 167     {
 168       hr = DXFILEERR_BADFILETYPE;
 169       goto error;
 170     }
 171     file_buffer = object->mapped_memory;
 172   }
 173   else if (dwLoadOptions == DXFILELOAD_FROMRESOURCE)
 174   {
 175     HRSRC resource_info;
 176     HGLOBAL resource_data;
 177     LPDXFILELOADRESOURCE lpdxflr = pvSource;
 178
 179     TRACE("Source in resource (module = %p, name = %s, type = %s)\n", lpdxflr->hModule, debugstr_a(lpdxflr->lpName), debugstr_a(lpdxflr->lpType));
 180
 181     resource_info = FindResourceA(lpdxflr->hModule, lpdxflr->lpName, lpdxflr->lpType);
 182     if (!resource_info)
 183     {
 184       hr = DXFILEERR_RESOURCENOTFOUND;
 185       goto error;
 186     }
 187
 188     file_size = SizeofResource(lpdxflr->hModule, resource_info);
 189
 190     resource_data = LoadResource(lpdxflr->hModule, resource_info);
 191     if (!resource_data)
 192     {
 193       hr = DXFILEERR_BADRESOURCE;
 194       goto error;
 195     }
 196
 197     file_buffer = LockResource(resource_data);
 198     if (!file_buffer)
 199     {
 200       hr = DXFILEERR_BADRESOURCE;
 201       goto error;
 202     }
 203   }
 204   else if (dwLoadOptions == DXFILELOAD_FROMMEMORY)
 205   {
 206     LPDXFILELOADMEMORY lpdxflm = pvSource;
 207
 208     TRACE("Source in memory at %p with size %ld.\n", lpdxflm->lpMemory, lpdxflm->dSize);
 209
 210     file_buffer = lpdxflm->lpMemory;
 211     file_size = lpdxflm->dSize;
 212   }
 213   else
 214   {
 215     FIXME("Source type %ld not handled yet.\n", dwLoadOptions);
 216     hr = DXFILEERR_NOTDONEYET;
 217     goto error;
 218   }
 219
 220   TRACE("File size is %lu bytes.\n", file_size);
 221
 222   if (TRACE_ON(d3dxof_dump))
 223   {
 224     static USHORT num;
 225     char tmp[12];
 226     HANDLE file;
 227     sprintf(tmp, "file%05u.x", num++);
 228
 229     file = CreateFileA(tmp, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, 0, NULL);
 230     if (file != INVALID_HANDLE_VALUE)
 231     {
 232       WriteFile(file, file_buffer, file_size, &bytes_written, NULL);
 233       CloseHandle(file);
 234     }
 235   }
 236
 237   object->pDirectXFile = This;
 238
 239   object->buf.pdxf = This;
 240   object->buf.token_present = FALSE;
 241   object->buf.buffer = file_buffer;
 242   object->buf.rem_bytes = file_size;
 243   hr = parse_header(&object->buf, &object->decomp_buffer);
 244   if (FAILED(hr))
 245     goto error;
 246
 247   /* Check if there are templates defined before the object */
 248   if (!parse_templates(&object->buf, TRUE))
 249   {
 250     hr = DXFILEERR_PARSEERROR;
 251     goto error;
 252   }
 253
 254   if (TRACE_ON(d3dxof))
 255   {
 256     ULONG i;
 257     TRACE("Registered templates (%lu):\n", This->nb_xtemplates);
 258     for (i = 1; i < This->nb_xtemplates; i++)
 259       TRACE("%s - %s\n", This->xtemplates[i].name, debugstr_guid(&This->xtemplates[i].class_id));
 260   }
 261
 262   *ppEnumObj = &object->IDirectXFileEnumObject_iface;
 263
 264   return DXFILE_OK;
 265
 266 error:
 267   IDirectXFileEnumObject_Release(&object->IDirectXFileEnumObject_iface);
 268   *ppEnumObj = NULL;
 269
 270   return hr;
 271 }
 272
 273 static HRESULT WINAPI IDirectXFileImpl_CreateSaveObject(IDirectXFile *iface, const char *filename,
 274         DXFILEFORMAT format, LPDIRECTXFILESAVEOBJECT *out)
 275 {
 276     IDirectXFileSaveObjectImpl *object;
 277     HRESULT hr;
 278
 279     FIXME("iface %p, filename %s, format %lu, out %p partial stub!\n", iface, debugstr_a(filename),
 280             format, out);
 281
 282     if (!filename || !out)
 283         return E_POINTER;
 284
 285     hr = IDirectXFileSaveObjectImpl_Create(&object);
 286     if (SUCCEEDED(hr))
 287         *out = &object->IDirectXFileSaveObject_iface;
 288     return hr;
 289 }
 290
 291 static HRESULT WINAPI IDirectXFileImpl_RegisterTemplates(IDirectXFile* iface, LPVOID pvData, DWORD cbSize)
 292 {
 293   IDirectXFileImpl *This = impl_from_IDirectXFile(iface);
 294   parse_buffer buf;
 295   HRESULT hr;
 296   LPBYTE decomp_buffer = NULL;
 297   DWORD bytes_written;
 298
 299   ZeroMemory(&buf, sizeof(buf));
 300   buf.buffer = pvData;
 301   buf.rem_bytes = cbSize;
 302   buf.pdxf = This;
 303
 304   TRACE("iface %p, data %p, size %lu.\n", iface, pvData, cbSize);
 305
 306   if (!pvData)
 307     return DXFILEERR_BADVALUE;
 308
 309   if (TRACE_ON(d3dxof_dump))
 310   {
 311     static USHORT num;
 312     char tmp[16];
 313     HANDLE file;
 314     sprintf(tmp, "template%05u.x", num++);
 315
 316     file = CreateFileA(tmp, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, 0, NULL);
 317     if (file != INVALID_HANDLE_VALUE)
 318     {
 319       WriteFile(file, pvData, cbSize, &bytes_written, NULL);
 320       CloseHandle(file);
 321     }
 322   }
 323
 324   hr = parse_header(&buf, &decomp_buffer);
 325   if (FAILED(hr))
 326     goto cleanup;
 327
 328   if (!parse_templates(&buf, FALSE))
 329   {
 330     hr = DXFILEERR_PARSEERROR;
 331     goto cleanup;
 332   }
 333
 334   if (TRACE_ON(d3dxof))
 335   {
 336       unsigned int i;
 337
 338       TRACE("Registered templates (%lu):\n", This->nb_xtemplates);
 339       for (i = 1; i < This->nb_xtemplates; ++i)
 340           TRACE("%s - %s\n", This->xtemplates[i].name, debugstr_guid(&This->xtemplates[i].class_id));
 341   }
 342
 343   hr = DXFILE_OK;
 344 cleanup:
 345   HeapFree(GetProcessHeap(), 0, decomp_buffer);
 346   return hr;
 347 }
 348
 349 static const IDirectXFileVtbl IDirectXFile_Vtbl =
 350 {
 351   IDirectXFileImpl_QueryInterface,
 352   IDirectXFileImpl_AddRef,
 353   IDirectXFileImpl_Release,
 354   IDirectXFileImpl_CreateEnumObject,
 355   IDirectXFileImpl_CreateSaveObject,
 356   IDirectXFileImpl_RegisterTemplates
 357 };
 358
 359 static HRESULT IDirectXFileBinaryImpl_Create(IDirectXFileBinaryImpl** ppObj)
 360 {
 361     IDirectXFileBinaryImpl* object;
 362
 363     TRACE("(%p)\n", ppObj);
 364
 365     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileBinaryImpl));
 366     if (!object)
 367         return DXFILEERR_BADALLOC;
 368
 369     object->IDirectXFileBinary_iface.lpVtbl = &IDirectXFileBinary_Vtbl;
 370     object->ref = 1;
 371
 372     *ppObj = object;
 373
 374     return DXFILE_OK;
 375 }
 376
 377 static inline IDirectXFileBinaryImpl *impl_from_IDirectXFileBinary(IDirectXFileBinary *iface)
 378 {
 379     return CONTAINING_RECORD(iface, IDirectXFileBinaryImpl, IDirectXFileBinary_iface);
 380 }
 381
 382 static HRESULT WINAPI IDirectXFileBinaryImpl_QueryInterface(IDirectXFileBinary *iface,
 383         REFIID riid, void **out)
 384 {
 385     IDirectXFileBinaryImpl *object = impl_from_IDirectXFileBinary(iface);
 386
 387     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 388
 389     if (IsEqualGUID(riid, &IID_IUnknown)
 390             || IsEqualGUID(riid, &IID_IDirectXFileObject)
 391             || IsEqualGUID(riid, &IID_IDirectXFileBinary))
 392     {
 393         *out = &object->IDirectXFileBinary_iface;
 394     }
 395     else
 396     {
 397         *out = NULL;
 398         /* Do not print an error for interfaces that can be queried to
 399          * retrieve the type of the object */
 400         if (!IsEqualGUID(riid, &IID_IDirectXFileData) && !IsEqualGUID(riid, &IID_IDirectXFileDataReference))
 401             WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 402         return E_NOINTERFACE;
 403     }
 404
 405     IUnknown_AddRef((IUnknown *)*out);
 406     return S_OK;
 407 }
 408
 409 static ULONG WINAPI IDirectXFileBinaryImpl_AddRef(IDirectXFileBinary *iface)
 410 {
 411     IDirectXFileBinaryImpl *object = impl_from_IDirectXFileBinary(iface);
 412     ULONG refcount = InterlockedIncrement(&object->ref);
 413
 414     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 415
 416     return refcount;
 417 }
 418
 419 static ULONG WINAPI IDirectXFileBinaryImpl_Release(IDirectXFileBinary *iface)
 420 {
 421     IDirectXFileBinaryImpl *object = impl_from_IDirectXFileBinary(iface);
 422     ULONG refcount = InterlockedDecrement(&object->ref);
 423
 424     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 425
 426     if (!refcount)
 427         HeapFree(GetProcessHeap(), 0, object);
 428
 429     return refcount;
 430 }
 431
 432 static HRESULT WINAPI IDirectXFileBinaryImpl_GetName(IDirectXFileBinary *iface, char *name,
 433         DWORD *length)
 434 {
 435     FIXME("iface %p, name %p, length %p stub!\n", iface, name, length);
 436
 437     return DXFILEERR_BADVALUE;
 438 }
 439
 440 static HRESULT WINAPI IDirectXFileBinaryImpl_GetId(IDirectXFileBinary *iface, GUID *guid)
 441 {
 442     FIXME("iface %p, guid %p stub!\n", iface, guid);
 443
 444     return DXFILEERR_BADVALUE;
 445 }
 446
 447 static HRESULT WINAPI IDirectXFileBinaryImpl_GetSize(IDirectXFileBinary *iface, DWORD *size)
 448 {
 449     FIXME("iface %p, size %p stub!\n", iface, size);
 450
 451     return DXFILEERR_BADVALUE;
 452 }
 453
 454 static HRESULT WINAPI IDirectXFileBinaryImpl_GetMimeType(IDirectXFileBinary *iface, LPCSTR *mimetype)
 455 {
 456     FIXME("iface %p, mimetype %p stub!\n", iface, mimetype);
 457
 458     return DXFILEERR_BADVALUE;
 459 }
 460
 461 static HRESULT WINAPI IDirectXFileBinaryImpl_Read(IDirectXFileBinary *iface, void *data,
 462         DWORD size, DWORD *count)
 463 {
 464     FIXME("iface %p, data %p, size %lu, count %p stub!\n", iface, data, size, count);
 465
 466     return DXFILEERR_BADVALUE;
 467 }
 468
 469 static const IDirectXFileBinaryVtbl IDirectXFileBinary_Vtbl =
 470 {
 471     IDirectXFileBinaryImpl_QueryInterface,
 472     IDirectXFileBinaryImpl_AddRef,
 473     IDirectXFileBinaryImpl_Release,
 474     IDirectXFileBinaryImpl_GetName,
 475     IDirectXFileBinaryImpl_GetId,
 476     IDirectXFileBinaryImpl_GetSize,
 477     IDirectXFileBinaryImpl_GetMimeType,
 478     IDirectXFileBinaryImpl_Read
 479 };
 480
 481 static HRESULT IDirectXFileDataImpl_Create(IDirectXFileDataImpl** ppObj)
 482 {
 483     IDirectXFileDataImpl* object;
 484
 485     TRACE("(%p)\n", ppObj);
 486
 487     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataImpl));
 488     if (!object)
 489         return DXFILEERR_BADALLOC;
 490
 491     object->IDirectXFileData_iface.lpVtbl = &IDirectXFileData_Vtbl;
 492     object->ref = 1;
 493
 494     *ppObj = object;
 495
 496     return S_OK;
 497 }
 498
 499 static inline IDirectXFileDataImpl *impl_from_IDirectXFileData(IDirectXFileData *iface)
 500 {
 501     return CONTAINING_RECORD(iface, IDirectXFileDataImpl, IDirectXFileData_iface);
 502 }
 503
 504 static HRESULT WINAPI IDirectXFileDataImpl_QueryInterface(IDirectXFileData *iface, REFIID riid,
 505         void **out)
 506 {
 507     IDirectXFileDataImpl *data = impl_from_IDirectXFileData(iface);
 508
 509     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 510
 511     if (IsEqualGUID(riid, &IID_IUnknown)
 512             || IsEqualGUID(riid, &IID_IDirectXFileObject)
 513             || IsEqualGUID(riid, &IID_IDirectXFileData))
 514     {
 515         *out = &data->IDirectXFileData_iface;
 516     }
 517     else
 518     {
 519         *out = NULL;
 520         /* Do not print an error for interfaces that can be queried to
 521          * retrieve the type of the object */
 522         if (!IsEqualGUID(riid, &IID_IDirectXFileBinary) && !IsEqualGUID(riid, &IID_IDirectXFileDataReference))
 523             WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 524         return E_NOINTERFACE;
 525     }
 526
 527     IUnknown_AddRef((IUnknown *)*out);
 528     return S_OK;
 529 }
 530
 531 static ULONG WINAPI IDirectXFileDataImpl_AddRef(IDirectXFileData *iface)
 532 {
 533     IDirectXFileDataImpl *data = impl_from_IDirectXFileData(iface);
 534     ULONG refcount = InterlockedIncrement(&data->ref);
 535
 536     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 537
 538     return refcount;
 539 }
 540
 541 static ULONG WINAPI IDirectXFileDataImpl_Release(IDirectXFileData *iface)
 542 {
 543     IDirectXFileDataImpl *data = impl_from_IDirectXFileData(iface);
 544     ULONG refcount = InterlockedDecrement(&data->ref);
 545
 546     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 547
 548     if (!refcount)
 549     {
 550         if (!data->level && !data->from_ref)
 551         {
 552             HeapFree(GetProcessHeap(), 0, data->pstrings);
 553             if (data->pobj)
 554             {
 555                 HeapFree(GetProcessHeap(), 0, data->pobj->pdata);
 556                 HeapFree(GetProcessHeap(), 0, data->pobj);
 557             }
 558         }
 559         HeapFree(GetProcessHeap(), 0, data);
 560     }
 561
 562     return refcount;
 563 }
 564
 565 /*** IDirectXFileObject methods ***/
 566 static HRESULT WINAPI IDirectXFileDataImpl_GetName(IDirectXFileData* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
 567 {
 568   IDirectXFileDataImpl *This = impl_from_IDirectXFileData(iface);
 569   DWORD len;
 570
 571   TRACE("(%p/%p)->(%p,%p)\n", This, iface, pstrNameBuf, pdwBufLen);
 572
 573   if (!pdwBufLen)
 574     return DXFILEERR_BADVALUE;
 575
 576   len = strlen(This->pobj->name);
 577   if (len)
 578     len++;
 579
 580   if (pstrNameBuf) {
 581     if (*pdwBufLen < len)
 582       return DXFILEERR_BADVALUE;
 583     CopyMemory(pstrNameBuf, This->pobj->name, len);
 584     /* Even if we return a size of 0, an empty string with a null byte must be returned */
 585     if (*pdwBufLen && !len)
 586       pstrNameBuf[0] = 0;
 587   }
 588   *pdwBufLen = len;
 589
 590   return DXFILE_OK;
 591 }
 592
 593 static HRESULT WINAPI IDirectXFileDataImpl_GetId(IDirectXFileData* iface, LPGUID pGuid)
 594 {
 595   IDirectXFileDataImpl *This = impl_from_IDirectXFileData(iface);
 596
 597   TRACE("(%p/%p)->(%p)\n", This, iface, pGuid);
 598
 599   if (!pGuid)
 600     return DXFILEERR_BADVALUE;
 601
 602   *pGuid = This->pobj->class_id;
 603
 604   return DXFILE_OK;
 605 }
 606
 607 /*** IDirectXFileData methods ***/
 608 static HRESULT WINAPI IDirectXFileDataImpl_GetData(IDirectXFileData* iface, LPCSTR szMember, DWORD* pcbSize, void** ppvData)
 609 {
 610   IDirectXFileDataImpl *This = impl_from_IDirectXFileData(iface);
 611
 612   TRACE("(%p/%p)->(%s,%p,%p)\n", This, iface, debugstr_a(szMember), pcbSize, ppvData);
 613
 614   if (!pcbSize || !ppvData)
 615     return DXFILEERR_BADVALUE;
 616
 617   if (szMember)
 618   {
 619     ULONG i;
 620     for (i = 0; i < This->pobj->nb_members; i++)
 621       if (!strcmp(This->pobj->members[i].name, szMember))
 622         break;
 623     if (i == This->pobj->nb_members)
 624     {
 625       WARN("Unknown member '%s'\n", szMember);
 626       return DXFILEERR_BADDATAREFERENCE;
 627     }
 628     *pcbSize = This->pobj->members[i].size;
 629     *ppvData = This->pobj->root->pdata + This->pobj->members[i].start;
 630   }
 631   else
 632   {
 633     *pcbSize = This->pobj->size;
 634     *ppvData = This->pobj->root->pdata + This->pobj->pos_data;
 635   }
 636
 637   return DXFILE_OK;
 638 }
 639
 640 static HRESULT WINAPI IDirectXFileDataImpl_GetType(IDirectXFileData* iface, const GUID** pguid)
 641 {
 642   IDirectXFileDataImpl *This = impl_from_IDirectXFileData(iface);
 643   static GUID guid;
 644
 645   TRACE("(%p/%p)->(%p)\n", This, iface, pguid);
 646
 647   if (!pguid)
 648     return DXFILEERR_BADVALUE;
 649
 650   guid = This->pobj->type;
 651   *pguid = &guid;
 652
 653   return DXFILE_OK;
 654 }
 655
 656 static HRESULT WINAPI IDirectXFileDataImpl_GetNextObject(IDirectXFileData* iface, LPDIRECTXFILEOBJECT* ppChildObj)
 657 {
 658   HRESULT hr;
 659   IDirectXFileDataImpl *This = impl_from_IDirectXFileData(iface);
 660
 661   TRACE("(%p/%p)->(%p)\n", This, iface, ppChildObj);
 662
 663   if (This->cur_enum_object >= This->pobj->nb_children)
 664   {
 665     *ppChildObj = NULL;
 666     return DXFILEERR_NOMOREOBJECTS;
 667   }
 668
 669   if (This->from_ref && (This->level >= 1))
 670   {
 671     /* Only 2 levels can be enumerated if the object is obtained from a reference */
 672     *ppChildObj = NULL;
 673     return DXFILEERR_NOMOREOBJECTS;
 674   }
 675
 676   if (This->pobj->children[This->cur_enum_object]->binary)
 677   {
 678     IDirectXFileBinaryImpl *object;
 679
 680     hr = IDirectXFileBinaryImpl_Create(&object);
 681     if (FAILED(hr))
 682       return hr;
 683
 684     *ppChildObj = (LPDIRECTXFILEOBJECT)&object->IDirectXFileBinary_iface;
 685   }
 686   else if (This->pobj->children[This->cur_enum_object]->ptarget)
 687   {
 688     IDirectXFileDataReferenceImpl *object;
 689
 690     hr = IDirectXFileDataReferenceImpl_Create(&object);
 691     if (FAILED(hr))
 692       return hr;
 693
 694     object->ptarget = This->pobj->children[This->cur_enum_object++]->ptarget;
 695
 696     *ppChildObj = (LPDIRECTXFILEOBJECT)&object->IDirectXFileDataReference_iface;
 697   }
 698   else
 699   {
 700     IDirectXFileDataImpl *object;
 701
 702     hr = IDirectXFileDataImpl_Create(&object);
 703     if (FAILED(hr))
 704       return hr;
 705
 706     object->pobj = This->pobj->children[This->cur_enum_object++];
 707     object->cur_enum_object = 0;
 708     object->from_ref = This->from_ref;
 709     object->level = This->level + 1;
 710
 711     *ppChildObj = (LPDIRECTXFILEOBJECT)&object->IDirectXFileData_iface;
 712   }
 713
 714   return DXFILE_OK;
 715 }
 716
 717 static HRESULT WINAPI IDirectXFileDataImpl_AddDataObject(IDirectXFileData *iface, LPDIRECTXFILEDATA data)
 718 {
 719     FIXME("iface %p, data %p stub!\n", iface, data);
 720
 721     return DXFILEERR_BADVALUE;
 722 }
 723
 724 static HRESULT WINAPI IDirectXFileDataImpl_AddDataReference(IDirectXFileData *iface,
 725         const char *reference, const GUID *guidref)
 726 {
 727     FIXME("iface %p, reference %s, guid reference %s stub!\n", iface, debugstr_a(reference),
 728             debugstr_guid(guidref));
 729
 730     return DXFILEERR_BADVALUE;
 731 }
 732
 733 static HRESULT WINAPI IDirectXFileDataImpl_AddBinaryObject(IDirectXFileData *iface, const char *name,
 734         const GUID *guid, const char *mimetype, void *data, DWORD size)
 735 {
 736     FIXME("iface %p, name %s, guid %s, mimetype %s, data %p, size %lu stub!\n", iface, debugstr_a(name),
 737             debugstr_guid(guid), debugstr_a(mimetype), data, size);
 738
 739     return DXFILEERR_BADVALUE;
 740 }
 741
 742 static const IDirectXFileDataVtbl IDirectXFileData_Vtbl =
 743 {
 744     IDirectXFileDataImpl_QueryInterface,
 745     IDirectXFileDataImpl_AddRef,
 746     IDirectXFileDataImpl_Release,
 747     IDirectXFileDataImpl_GetName,
 748     IDirectXFileDataImpl_GetId,
 749     IDirectXFileDataImpl_GetData,
 750     IDirectXFileDataImpl_GetType,
 751     IDirectXFileDataImpl_GetNextObject,
 752     IDirectXFileDataImpl_AddDataObject,
 753     IDirectXFileDataImpl_AddDataReference,
 754     IDirectXFileDataImpl_AddBinaryObject
 755 };
 756
 757 static HRESULT IDirectXFileDataReferenceImpl_Create(IDirectXFileDataReferenceImpl** ppObj)
 758 {
 759     IDirectXFileDataReferenceImpl* object;
 760
 761     TRACE("(%p)\n", ppObj);
 762
 763     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataReferenceImpl));
 764     if (!object)
 765         return DXFILEERR_BADALLOC;
 766
 767     object->IDirectXFileDataReference_iface.lpVtbl = &IDirectXFileDataReference_Vtbl;
 768     object->ref = 1;
 769
 770     *ppObj = object;
 771
 772     return S_OK;
 773 }
 774
 775 static inline IDirectXFileDataReferenceImpl *impl_from_IDirectXFileDataReference(IDirectXFileDataReference *iface)
 776 {
 777     return CONTAINING_RECORD(iface, IDirectXFileDataReferenceImpl, IDirectXFileDataReference_iface);
 778 }
 779
 780 static HRESULT WINAPI IDirectXFileDataReferenceImpl_QueryInterface(IDirectXFileDataReference *iface,
 781         REFIID riid, void **out)
 782 {
 783     IDirectXFileDataReferenceImpl *object = impl_from_IDirectXFileDataReference(iface);
 784
 785     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 786
 787     if (IsEqualGUID(riid, &IID_IUnknown)
 788             || IsEqualGUID(riid, &IID_IDirectXFileObject)
 789             || IsEqualGUID(riid, &IID_IDirectXFileDataReference))
 790     {
 791         *out = &object->IDirectXFileDataReference_iface;
 792     }
 793     else
 794     {
 795         /* Do not print an error for interfaces that can be queried to
 796          * retrieve the type of the object */
 797         *out = NULL;
 798         if (!IsEqualGUID(riid, &IID_IDirectXFileData) && !IsEqualGUID(riid, &IID_IDirectXFileBinary))
 799             WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 800         return E_NOINTERFACE;
 801     }
 802
 803     IUnknown_AddRef((IUnknown *)*out);
 804     return S_OK;
 805 }
 806
 807 static ULONG WINAPI IDirectXFileDataReferenceImpl_AddRef(IDirectXFileDataReference *iface)
 808 {
 809     IDirectXFileDataReferenceImpl *object = impl_from_IDirectXFileDataReference(iface);
 810     ULONG refcount = InterlockedIncrement(&object->ref);
 811
 812     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 813
 814     return refcount;
 815 }
 816
 817 static ULONG WINAPI IDirectXFileDataReferenceImpl_Release(IDirectXFileDataReference *iface)
 818 {
 819     IDirectXFileDataReferenceImpl *object = impl_from_IDirectXFileDataReference(iface);
 820     ULONG refcount = InterlockedDecrement(&object->ref);
 821
 822     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 823
 824     if (!refcount)
 825         HeapFree(GetProcessHeap(), 0, object);
 826
 827     return refcount;
 828 }
 829
 830 /*** IDirectXFileObject methods ***/
 831 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetName(IDirectXFileDataReference* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
 832 {
 833   IDirectXFileDataReferenceImpl *This = impl_from_IDirectXFileDataReference(iface);
 834   DWORD len;
 835
 836   TRACE("(%p/%p)->(%p,%p)\n", This, iface, pstrNameBuf, pdwBufLen);
 837
 838   if (!pdwBufLen)
 839     return DXFILEERR_BADVALUE;
 840
 841   len = strlen(This->ptarget->name);
 842   if (len)
 843     len++;
 844
 845   if (pstrNameBuf) {
 846     if (*pdwBufLen < len)
 847       return DXFILEERR_BADVALUE;
 848     CopyMemory(pstrNameBuf, This->ptarget->name, len);
 849     /* Even if we return a size of 0, an empty string with a null byte must be returned */
 850     if (*pdwBufLen && !len)
 851       pstrNameBuf[0] = 0;
 852   }
 853   *pdwBufLen = len;
 854
 855   return DXFILE_OK;
 856 }
 857
 858 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetId(IDirectXFileDataReference *iface,
 859         GUID *guid)
 860 {
 861     IDirectXFileDataReferenceImpl *object = impl_from_IDirectXFileDataReference(iface);
 862
 863     TRACE("iface %p, guid %p.\n", iface, guid);
 864
 865     if (!guid)
 866         return DXFILEERR_BADVALUE;
 867
 868     *guid = object->ptarget->class_id;
 869
 870     return DXFILE_OK;
 871 }
 872
 873 /*** IDirectXFileDataReference ***/
 874 static HRESULT WINAPI IDirectXFileDataReferenceImpl_Resolve(IDirectXFileDataReference* iface, LPDIRECTXFILEDATA* ppDataObj)
 875 {
 876   IDirectXFileDataReferenceImpl *This = impl_from_IDirectXFileDataReference(iface);
 877   IDirectXFileDataImpl *object;
 878   HRESULT hr;
 879
 880   TRACE("(%p/%p)->(%p)\n", This, iface, ppDataObj);
 881
 882   if (!ppDataObj)
 883     return DXFILEERR_BADVALUE;
 884
 885   hr = IDirectXFileDataImpl_Create(&object);
 886   if (FAILED(hr))
 887     return hr;
 888
 889   object->pobj = This->ptarget;
 890   object->cur_enum_object = 0;
 891   object->level = 0;
 892   object->from_ref = TRUE;
 893
 894   *ppDataObj = &object->IDirectXFileData_iface;
 895
 896   return DXFILE_OK;
 897 }
 898
 899 static const IDirectXFileDataReferenceVtbl IDirectXFileDataReference_Vtbl =
 900 {
 901     IDirectXFileDataReferenceImpl_QueryInterface,
 902     IDirectXFileDataReferenceImpl_AddRef,
 903     IDirectXFileDataReferenceImpl_Release,
 904     IDirectXFileDataReferenceImpl_GetName,
 905     IDirectXFileDataReferenceImpl_GetId,
 906     IDirectXFileDataReferenceImpl_Resolve
 907 };
 908
 909 static HRESULT IDirectXFileEnumObjectImpl_Create(IDirectXFileEnumObjectImpl** ppObj)
 910 {
 911     IDirectXFileEnumObjectImpl* object;
 912
 913     TRACE("(%p)\n", ppObj);
 914
 915     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileEnumObjectImpl));
 916     if (!object)
 917         return DXFILEERR_BADALLOC;
 918
 919     object->IDirectXFileEnumObject_iface.lpVtbl = &IDirectXFileEnumObject_Vtbl;
 920     object->ref = 1;
 921
 922     *ppObj = object;
 923
 924     return S_OK;
 925 }
 926
 927 static inline IDirectXFileEnumObjectImpl *impl_from_IDirectXFileEnumObject(IDirectXFileEnumObject *iface)
 928 {
 929     return CONTAINING_RECORD(iface, IDirectXFileEnumObjectImpl, IDirectXFileEnumObject_iface);
 930 }
 931
 932 static HRESULT WINAPI IDirectXFileEnumObjectImpl_QueryInterface(IDirectXFileEnumObject *iface,
 933         REFIID riid, void **out)
 934 {
 935     IDirectXFileEnumObjectImpl *object = impl_from_IDirectXFileEnumObject(iface);
 936
 937     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 938
 939     if (IsEqualGUID(riid, &IID_IUnknown)
 940             || IsEqualGUID(riid, &IID_IDirectXFileEnumObject))
 941     {
 942         *out = &object->IDirectXFileEnumObject_iface;
 943     }
 944     else
 945     {
 946         *out = NULL;
 947         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 948         return E_NOINTERFACE;
 949     }
 950
 951     IUnknown_AddRef((IUnknown *)*out);
 952     return S_OK;
 953 }
 954
 955 static ULONG WINAPI IDirectXFileEnumObjectImpl_AddRef(IDirectXFileEnumObject *iface)
 956 {
 957     IDirectXFileEnumObjectImpl *object = impl_from_IDirectXFileEnumObject(iface);
 958     ULONG refcount = InterlockedIncrement(&object->ref);
 959
 960     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 961
 962     return refcount;
 963 }
 964
 965 static ULONG WINAPI IDirectXFileEnumObjectImpl_Release(IDirectXFileEnumObject *iface)
 966 {
 967     IDirectXFileEnumObjectImpl *object = impl_from_IDirectXFileEnumObject(iface);
 968     ULONG refcount = InterlockedDecrement(&object->ref);
 969
 970     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 971
 972     if (!refcount)
 973     {
 974         unsigned int i;
 975
 976         for (i = 0; i < object->nb_xobjects; ++i)
 977             IDirectXFileData_Release(object->pRefObjects[i]);
 978         if (object->mapped_memory)
 979             UnmapViewOfFile(object->mapped_memory);
 980         HeapFree(GetProcessHeap(), 0, object->decomp_buffer);
 981         HeapFree(GetProcessHeap(), 0, object);
 982     }
 983
 984     return refcount;
 985 }
 986
 987 /*** IDirectXFileEnumObject methods ***/
 988 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetNextDataObject(IDirectXFileEnumObject* iface, LPDIRECTXFILEDATA* ppDataObj)
 989 {
 990   IDirectXFileEnumObjectImpl *This = impl_from_IDirectXFileEnumObject(iface);
 991   IDirectXFileDataImpl* object;
 992   HRESULT hr;
 993
 994   if (!ppDataObj)
 995     return E_POINTER;
 996
 997   *ppDataObj = NULL;
 998
 999   TRACE("(%p/%p)->(%p)\n", This, iface, ppDataObj);
1000
1001   if (This->nb_xobjects >= MAX_OBJECTS)
1002   {
1003     ERR("Too many objects\n");
1004     return DXFILEERR_NOMOREOBJECTS;
1005   }
1006
1007   /* Check if there are templates defined before the object */
1008   if (!parse_templates(&This->buf, TRUE))
1009     return DXFILEERR_PARSEERROR;
1010
1011   if (!This->buf.rem_bytes)
1012     return DXFILEERR_NOMOREOBJECTS;
1013
1014   hr = IDirectXFileDataImpl_Create(&object);
1015   if (FAILED(hr))
1016     return hr;
1017
1018   object->pobj = HeapAlloc(GetProcessHeap(), 0, sizeof(xobject)*MAX_SUBOBJECTS);
1019   if (!object->pobj)
1020   {
1021     hr = DXFILEERR_BADALLOC;
1022     goto error;
1023   }
1024
1025   object->pstrings = HeapAlloc(GetProcessHeap(), 0, MAX_STRINGS_BUFFER);
1026   if (!object->pstrings)
1027   {
1028     hr = DXFILEERR_BADALLOC;
1029     goto error;
1030   }
1031
1032   object->cur_enum_object = 0;
1033   object->level = 0;
1034   object->from_ref = FALSE;
1035
1036   This->buf.pxo_globals = This->xobjects;
1037   This->buf.nb_pxo_globals = This->nb_xobjects;
1038   This->buf.level = 0;
1039   This->buf.pdata = NULL;
1040   This->buf.capacity = 0;
1041   This->buf.cur_pos_data = 0;
1042   This->buf.cur_pstrings = This->buf.pstrings = object->pstrings;
1043   This->buf.pxo = This->xobjects[This->nb_xobjects] = This->buf.pxo_tab = object->pobj;
1044   This->buf.pxo->pdata = NULL;
1045   This->buf.pxo->nb_subobjects = 1;
1046
1047   if (!parse_object(&This->buf))
1048   {
1049     WARN("Object is not correct\n");
1050     hr = DXFILEERR_PARSEERROR;
1051     goto error;
1052   }
1053
1054   *ppDataObj = &object->IDirectXFileData_iface;
1055
1056   /* Get a reference to created object */
1057   This->pRefObjects[This->nb_xobjects] = &object->IDirectXFileData_iface;
1058   IDirectXFileData_AddRef(This->pRefObjects[This->nb_xobjects]);
1059
1060   This->nb_xobjects++;
1061
1062   return DXFILE_OK;
1063
1064 error:
1065
1066   IDirectXFileData_Release(&object->IDirectXFileData_iface);
1067
1068   return hr;
1069 }
1070
1071 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectById(IDirectXFileEnumObject *iface,
1072         REFGUID guid, LPDIRECTXFILEDATA *data)
1073 {
1074     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
1075
1076     return DXFILEERR_BADVALUE;
1077 }
1078
1079 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectByName(IDirectXFileEnumObject *iface,
1080         const char *name, LPDIRECTXFILEDATA *data)
1081 {
1082     FIXME("iface %p, name %s, data %p stub!\n", iface, debugstr_a(name), data);
1083
1084     return DXFILEERR_BADVALUE;
1085 }
1086
1087 static const IDirectXFileEnumObjectVtbl IDirectXFileEnumObject_Vtbl =
1088 {
1089     IDirectXFileEnumObjectImpl_QueryInterface,
1090     IDirectXFileEnumObjectImpl_AddRef,
1091     IDirectXFileEnumObjectImpl_Release,
1092     IDirectXFileEnumObjectImpl_GetNextDataObject,
1093     IDirectXFileEnumObjectImpl_GetDataObjectById,
1094     IDirectXFileEnumObjectImpl_GetDataObjectByName
1095 };
1096
1097 static HRESULT IDirectXFileSaveObjectImpl_Create(IDirectXFileSaveObjectImpl** ppObj)
1098 {
1099     IDirectXFileSaveObjectImpl* object;
1100
1101     TRACE("(%p)\n", ppObj);
1102
1103     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileSaveObjectImpl));
1104     if (!object)
1105         return DXFILEERR_BADALLOC;
1106
1107     object->IDirectXFileSaveObject_iface.lpVtbl = &IDirectXFileSaveObject_Vtbl;
1108     object->ref = 1;
1109
1110     *ppObj = object;
1111
1112     return S_OK;
1113 }
1114
1115 static inline IDirectXFileSaveObjectImpl *impl_from_IDirectXFileSaveObject(IDirectXFileSaveObject *iface)
1116 {
1117     return CONTAINING_RECORD(iface, IDirectXFileSaveObjectImpl, IDirectXFileSaveObject_iface);
1118 }
1119
1120 static HRESULT WINAPI IDirectXFileSaveObjectImpl_QueryInterface(IDirectXFileSaveObject *iface,
1121         REFIID riid, void **out)
1122 {
1123     IDirectXFileSaveObjectImpl *object = impl_from_IDirectXFileSaveObject(iface);
1124
1125     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
1126
1127     if (IsEqualGUID(riid, &IID_IUnknown)
1128             || IsEqualGUID(riid, &IID_IDirectXFileSaveObject))
1129     {
1130         *out = &object->IDirectXFileSaveObject_iface;
1131     }
1132     else
1133     {
1134         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1135         return E_NOINTERFACE;
1136     }
1137
1138     IUnknown_AddRef((IUnknown *)*out);
1139     return S_OK;
1140 }
1141
1142 static ULONG WINAPI IDirectXFileSaveObjectImpl_AddRef(IDirectXFileSaveObject *iface)
1143 {
1144     IDirectXFileSaveObjectImpl *object = impl_from_IDirectXFileSaveObject(iface);
1145     ULONG refcount = InterlockedIncrement(&object->ref);
1146
1147     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
1148
1149     return refcount;
1150 }
1151
1152 static ULONG WINAPI IDirectXFileSaveObjectImpl_Release(IDirectXFileSaveObject *iface)
1153 {
1154     IDirectXFileSaveObjectImpl *object = impl_from_IDirectXFileSaveObject(iface);
1155     ULONG refcount = InterlockedDecrement(&object->ref);
1156
1157     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
1158
1159     if (!refcount)
1160         HeapFree(GetProcessHeap(), 0, object);
1161
1162     return refcount;
1163 }
1164
1165 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveTemplates(IDirectXFileSaveObject *iface,
1166         DWORD count, const GUID **templates)
1167 {
1168     FIXME("iface %p, count %lu, templates %p stub!\n", iface, count, templates);
1169
1170     return DXFILE_OK;
1171 }
1172
1173 static HRESULT WINAPI IDirectXFileSaveObjectImpl_CreateDataObject(IDirectXFileSaveObject *iface, REFGUID template,
1174         const char *name, const GUID *guid, DWORD size, void *data, LPDIRECTXFILEDATA *dataobj)
1175 {
1176     FIXME("iface %p, template %s, name %s, guid %s, size %lu, data %p, dataobj %p stub!\n",
1177             iface, debugstr_guid(template), debugstr_a(name), debugstr_guid(guid), size, data, dataobj);
1178
1179     return DXFILEERR_BADVALUE;
1180 }
1181
1182 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveData(IDirectXFileSaveObject *iface, LPDIRECTXFILEDATA data)
1183 {
1184     FIXME("iface %p, data %p stub!\n", iface, data);
1185
1186     return DXFILEERR_BADVALUE;
1187 }
1188
1189 static const IDirectXFileSaveObjectVtbl IDirectXFileSaveObject_Vtbl =
1190 {
1191     IDirectXFileSaveObjectImpl_QueryInterface,
1192     IDirectXFileSaveObjectImpl_AddRef,
1193     IDirectXFileSaveObjectImpl_Release,
1194     IDirectXFileSaveObjectImpl_SaveTemplates,
1195     IDirectXFileSaveObjectImpl_CreateDataObject,
1196     IDirectXFileSaveObjectImpl_SaveData
1197 };