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