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