dlls/d3dx9_36/xfile.c

   1 /*
   2  * Copyright (C) 2012 Christian Costa
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20
  21 #include "d3dx9_private.h"
  22 #include "d3dx9xof.h"
  23 #undef MAKE_DDHRESULT
  24 #include "dxfile.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  27
  28 static HRESULT error_dxfile_to_d3dxfile(HRESULT error)
  29 {
  30     switch (error)
  31     {
  32         case DXFILEERR_BADFILETYPE:
  33             return D3DXFERR_BADFILETYPE;
  34         case DXFILEERR_BADFILEVERSION:
  35             return D3DXFERR_BADFILEVERSION;
  36         case DXFILEERR_BADFILEFLOATSIZE:
  37             return D3DXFERR_BADFILEFLOATSIZE;
  38         case DXFILEERR_PARSEERROR:
  39             return D3DXFERR_PARSEERROR;
  40         case DXFILEERR_BADVALUE:
  41             return D3DXFERR_BADVALUE;
  42         default:
  43             FIXME("Cannot map error %#lx.\n", error);
  44             return E_FAIL;
  45     }
  46 }
  47
  48 struct d3dx9_file
  49 {
  50     ID3DXFile ID3DXFile_iface;
  51     LONG ref;
  52     IDirectXFile *dxfile;
  53 };
  54
  55 struct d3dx9_file_enum_object
  56 {
  57     ID3DXFileEnumObject ID3DXFileEnumObject_iface;
  58     LONG ref;
  59     unsigned int child_count;
  60     ID3DXFileData **children;
  61 };
  62
  63 struct d3dx9_file_data
  64 {
  65     ID3DXFileData ID3DXFileData_iface;
  66     LONG ref;
  67     BOOL reference;
  68     IDirectXFileData *dxfile_data;
  69     unsigned int child_count;
  70     ID3DXFileData **children;
  71 };
  72
  73 static inline struct d3dx9_file *impl_from_ID3DXFile(ID3DXFile *iface)
  74 {
  75     return CONTAINING_RECORD(iface, struct d3dx9_file, ID3DXFile_iface);
  76 }
  77
  78 static inline struct d3dx9_file_enum_object *impl_from_ID3DXFileEnumObject(ID3DXFileEnumObject *iface)
  79 {
  80     return CONTAINING_RECORD(iface, struct d3dx9_file_enum_object, ID3DXFileEnumObject_iface);
  81 }
  82
  83 static inline struct d3dx9_file_data *impl_from_ID3DXFileData(ID3DXFileData *iface)
  84 {
  85     return CONTAINING_RECORD(iface, struct d3dx9_file_data, ID3DXFileData_iface);
  86 }
  87
  88 static HRESULT WINAPI d3dx9_file_data_QueryInterface(ID3DXFileData *iface, REFIID riid, void **out)
  89 {
  90     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  91
  92     if (IsEqualGUID(riid, &IID_ID3DXFileData)
  93             || IsEqualGUID(riid, &IID_IUnknown))
  94     {
  95         iface->lpVtbl->AddRef(iface);
  96         *out = iface;
  97         return S_OK;
  98     }
  99
 100     WARN("Interface %s not found.\n", debugstr_guid(riid));
 101
 102     *out = NULL;
 103     return E_NOINTERFACE;
 104 }
 105
 106 static ULONG WINAPI d3dx9_file_data_AddRef(ID3DXFileData *iface)
 107 {
 108     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 109     ULONG refcount = InterlockedIncrement(&file_data->ref);
 110
 111     TRACE("%p increasing refcount to %lu.\n", file_data, refcount);
 112
 113     return refcount;
 114 }
 115
 116 static ULONG WINAPI d3dx9_file_data_Release(ID3DXFileData *iface)
 117 {
 118     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 119     ULONG refcount = InterlockedDecrement(&file_data->ref);
 120
 121     TRACE("%p decreasing refcount to %lu.\n", file_data, refcount);
 122
 123     if (!refcount)
 124     {
 125         ULONG i;
 126
 127         for (i = 0; i < file_data->child_count; ++i)
 128         {
 129             ID3DXFileData *child = file_data->children[i];
 130             child->lpVtbl->Release(child);
 131         }
 132         HeapFree(GetProcessHeap(), 0, file_data->children);
 133         IDirectXFileData_Release(file_data->dxfile_data);
 134         HeapFree(GetProcessHeap(), 0, file_data);
 135     }
 136
 137     return refcount;
 138 }
 139
 140 static HRESULT WINAPI d3dx9_file_data_GetEnum(ID3DXFileData *iface, ID3DXFileEnumObject **enum_object)
 141 {
 142     FIXME("iface %p, enum_object %p stub!\n", iface, enum_object);
 143
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI d3dx9_file_data_GetName(ID3DXFileData *iface, char *name, SIZE_T *size)
 148 {
 149     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 150     DWORD dxfile_size;
 151     HRESULT ret;
 152
 153     TRACE("iface %p, name %p, size %p.\n", iface, name, size);
 154
 155     if (!size)
 156         return D3DXFERR_BADVALUE;
 157
 158     dxfile_size = *size;
 159
 160     ret = IDirectXFileData_GetName(file_data->dxfile_data, name, &dxfile_size);
 161     if (ret != DXFILE_OK)
 162         return error_dxfile_to_d3dxfile(ret);
 163
 164     if (!dxfile_size)
 165     {
 166         /* Contrary to d3dxof, d3dx9_36 returns an empty string with a null byte when no name is available.
 167          * If the input size is 0, it returns a length of 1 without touching the buffer */
 168         dxfile_size = 1;
 169         if (name && *size)
 170             name[0] = 0;
 171     }
 172
 173     *size = dxfile_size;
 174
 175     return S_OK;
 176 }
 177
 178 static HRESULT WINAPI d3dx9_file_data_GetId(ID3DXFileData *iface, GUID *guid)
 179 {
 180     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 181     HRESULT ret;
 182
 183     TRACE("iface %p, guid %p.\n", iface, guid);
 184
 185     if (!guid)
 186         return E_POINTER;
 187
 188     ret = IDirectXFileData_GetId(file_data->dxfile_data, guid);
 189     if (ret != DXFILE_OK)
 190         return error_dxfile_to_d3dxfile(ret);
 191
 192     return S_OK;
 193 }
 194
 195 static HRESULT WINAPI d3dx9_file_data_Lock(ID3DXFileData *iface, SIZE_T *size, const void **data)
 196 {
 197     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 198     DWORD dxfile_size;
 199     HRESULT ret;
 200
 201     TRACE("iface %p, size %p, data %p.\n", iface, size, data);
 202
 203     if (!size || !data)
 204         return E_POINTER;
 205
 206     ret = IDirectXFileData_GetData(file_data->dxfile_data, NULL, &dxfile_size, (void **)data);
 207     if (ret != DXFILE_OK)
 208         return error_dxfile_to_d3dxfile(ret);
 209
 210     *size = dxfile_size;
 211
 212     return S_OK;
 213 }
 214
 215 static HRESULT WINAPI d3dx9_file_data_Unlock(ID3DXFileData *iface)
 216 {
 217     TRACE("iface %p.\n", iface);
 218
 219     /* Nothing to do */
 220
 221     return S_OK;
 222 }
 223
 224 static HRESULT WINAPI d3dx9_file_data_GetType(ID3DXFileData *iface, GUID *guid)
 225 {
 226     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 227     const GUID *dxfile_guid;
 228     HRESULT ret;
 229
 230     TRACE("iface %p, guid %p.\n", iface, guid);
 231
 232     ret = IDirectXFileData_GetType(file_data->dxfile_data, &dxfile_guid);
 233     if (ret != DXFILE_OK)
 234         return error_dxfile_to_d3dxfile(ret);
 235
 236     *guid = *dxfile_guid;
 237
 238     return S_OK;
 239 }
 240
 241 static BOOL WINAPI d3dx9_file_data_IsReference(ID3DXFileData *iface)
 242 {
 243     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 244
 245     TRACE("iface %p.\n", iface);
 246
 247     return file_data->reference;
 248 }
 249
 250 static HRESULT WINAPI d3dx9_file_data_GetChildren(ID3DXFileData *iface, SIZE_T *children)
 251 {
 252     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 253
 254     TRACE("iface %p, children %p.\n", iface, children);
 255
 256     if (!children)
 257         return E_POINTER;
 258
 259     *children = file_data->child_count;
 260
 261     return S_OK;
 262 }
 263
 264 static HRESULT WINAPI d3dx9_file_data_GetChild(ID3DXFileData *iface, SIZE_T id, ID3DXFileData **object)
 265 {
 266     struct d3dx9_file_data *file_data = impl_from_ID3DXFileData(iface);
 267
 268     TRACE("iface %p, id %#Ix, object %p.\n", iface, id, object);
 269
 270     if (!object)
 271         return E_POINTER;
 272
 273     *object = file_data->children[id];
 274     (*object)->lpVtbl->AddRef(*object);
 275
 276     return S_OK;
 277 }
 278
 279 static const ID3DXFileDataVtbl d3dx9_file_data_vtbl =
 280 {
 281     d3dx9_file_data_QueryInterface,
 282     d3dx9_file_data_AddRef,
 283     d3dx9_file_data_Release,
 284     d3dx9_file_data_GetEnum,
 285     d3dx9_file_data_GetName,
 286     d3dx9_file_data_GetId,
 287     d3dx9_file_data_Lock,
 288     d3dx9_file_data_Unlock,
 289     d3dx9_file_data_GetType,
 290     d3dx9_file_data_IsReference,
 291     d3dx9_file_data_GetChildren,
 292     d3dx9_file_data_GetChild,
 293 };
 294
 295 static HRESULT d3dx9_file_data_create(IDirectXFileObject *dxfile_object, ID3DXFileData **ret_iface)
 296 {
 297     struct d3dx9_file_data *object;
 298     IDirectXFileObject *data_object;
 299     unsigned int children_array_size = 0;
 300     HRESULT ret;
 301
 302     TRACE("dxfile_object %p, ret_iface %p.\n", dxfile_object, ret_iface);
 303
 304     *ret_iface = NULL;
 305
 306     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 307     if (!object)
 308         return E_OUTOFMEMORY;
 309
 310     object->ID3DXFileData_iface.lpVtbl = &d3dx9_file_data_vtbl;
 311     object->ref = 1;
 312
 313     ret = IDirectXFileObject_QueryInterface(dxfile_object, &IID_IDirectXFileData, (void **)&object->dxfile_data);
 314     if (FAILED(ret))
 315     {
 316         IDirectXFileDataReference *reference;
 317
 318         ret = IDirectXFileObject_QueryInterface(dxfile_object, &IID_IDirectXFileDataReference, (void **)&reference);
 319         if (SUCCEEDED(ret))
 320         {
 321             ret = IDirectXFileDataReference_Resolve(reference, &object->dxfile_data);
 322             IUnknown_Release(reference);
 323             if (FAILED(ret))
 324             {
 325                 HeapFree(GetProcessHeap(), 0, object);
 326                 return E_FAIL;
 327             }
 328             object->reference = TRUE;
 329         }
 330         else
 331         {
 332             FIXME("Don't know what to do with binary object\n");
 333             HeapFree(GetProcessHeap(), 0, object);
 334             return E_FAIL;
 335         }
 336     }
 337
 338     while (SUCCEEDED(ret = IDirectXFileData_GetNextObject(object->dxfile_data, &data_object)))
 339     {
 340         if (object->child_count >= children_array_size)
 341         {
 342             ID3DXFileData **new_children;
 343
 344             if (object->children)
 345             {
 346                 children_array_size *= 2;
 347                 new_children = HeapReAlloc(GetProcessHeap(), 0, object->children,
 348                         sizeof(*object->children) * children_array_size);
 349             }
 350             else
 351             {
 352                 children_array_size = 4;
 353                 new_children = HeapAlloc(GetProcessHeap(), 0, sizeof(*object->children) * children_array_size);
 354             }
 355             if (!new_children)
 356             {
 357                 ret = E_OUTOFMEMORY;
 358                 break;
 359             }
 360             object->children = new_children;
 361         }
 362         ret = d3dx9_file_data_create(data_object, &object->children[object->child_count]);
 363         IUnknown_Release(data_object);
 364         if (FAILED(ret))
 365             break;
 366         ++object->child_count;
 367     }
 368     if (ret != DXFILEERR_NOMOREOBJECTS)
 369     {
 370         (&object->ID3DXFileData_iface)->lpVtbl->Release(&object->ID3DXFileData_iface);
 371         return ret;
 372     }
 373     if (object->children)
 374     {
 375         ID3DXFileData **new_children;
 376
 377         new_children = HeapReAlloc(GetProcessHeap(), 0, object->children,
 378                 sizeof(*object->children) * object->child_count);
 379         if (new_children)
 380             object->children = new_children;
 381     }
 382
 383     TRACE("Found %u children.\n", object->child_count);
 384
 385     *ret_iface = &object->ID3DXFileData_iface;
 386
 387     return S_OK;
 388 }
 389
 390 static HRESULT WINAPI d3dx9_file_enum_object_QueryInterface(ID3DXFileEnumObject *iface, REFIID riid, void **out)
 391 {
 392     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 393
 394     if (IsEqualGUID(riid, &IID_ID3DXFileEnumObject)
 395             || IsEqualGUID(riid, &IID_IUnknown))
 396     {
 397         iface->lpVtbl->AddRef(iface);
 398         *out = iface;
 399         return S_OK;
 400     }
 401
 402     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 403
 404     *out = NULL;
 405     return E_NOINTERFACE;
 406 }
 407
 408 static ULONG WINAPI d3dx9_file_enum_object_AddRef(ID3DXFileEnumObject *iface)
 409 {
 410     struct d3dx9_file_enum_object *file_enum = impl_from_ID3DXFileEnumObject(iface);
 411     ULONG refcount = InterlockedIncrement(&file_enum->ref);
 412
 413     TRACE("%p increasing refcount to %lu.\n", file_enum, refcount);
 414
 415     return refcount;
 416 }
 417
 418 static ULONG WINAPI d3dx9_file_enum_object_Release(ID3DXFileEnumObject *iface)
 419 {
 420     struct d3dx9_file_enum_object *file_enum = impl_from_ID3DXFileEnumObject(iface);
 421     ULONG refcount = InterlockedDecrement(&file_enum->ref);
 422
 423     TRACE("%p decreasing refcount to %lu.\n", file_enum, refcount);
 424
 425     if (!refcount)
 426     {
 427         ULONG i;
 428
 429         for (i = 0; i < file_enum->child_count; ++i)
 430         {
 431             ID3DXFileData *child = file_enum->children[i];
 432             child->lpVtbl->Release(child);
 433         }
 434         HeapFree(GetProcessHeap(), 0, file_enum->children);
 435         HeapFree(GetProcessHeap(), 0, file_enum);
 436     }
 437
 438     return refcount;
 439 }
 440
 441 static HRESULT WINAPI d3dx9_file_enum_object_GetFile(ID3DXFileEnumObject *iface, ID3DXFile **file)
 442 {
 443     FIXME("iface %p, file %p stub!\n", iface, file);
 444
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI d3dx9_file_enum_object_GetChildren(ID3DXFileEnumObject *iface, SIZE_T *children)
 449 {
 450     struct d3dx9_file_enum_object *file_enum = impl_from_ID3DXFileEnumObject(iface);
 451
 452     TRACE("iface %p, children %p.\n", iface, children);
 453
 454     if (!children)
 455         return E_POINTER;
 456
 457     *children = file_enum->child_count;
 458
 459     return S_OK;
 460 }
 461
 462 static HRESULT WINAPI d3dx9_file_enum_object_GetChild(ID3DXFileEnumObject *iface, SIZE_T id, ID3DXFileData **object)
 463 {
 464     struct d3dx9_file_enum_object *file_enum = impl_from_ID3DXFileEnumObject(iface);
 465
 466     TRACE("iface %p, id %#Ix, object %p.\n", iface, id, object);
 467
 468     if (!object)
 469         return E_POINTER;
 470
 471     *object = file_enum->children[id];
 472     (*object)->lpVtbl->AddRef(*object);
 473
 474     return S_OK;
 475 }
 476
 477 static HRESULT WINAPI d3dx9_file_enum_object_GetDataObjectById(ID3DXFileEnumObject *iface,
 478         REFGUID guid, ID3DXFileData **object)
 479 {
 480     FIXME("iface %p, guid %s, object %p stub!\n", iface, debugstr_guid(guid), object);
 481
 482     return E_NOTIMPL;
 483 }
 484
 485 static HRESULT WINAPI d3dx9_file_enum_object_GetDataObjectByName(ID3DXFileEnumObject *iface,
 486         const char *name, ID3DXFileData **object)
 487 {
 488     FIXME("iface %p, name %s, object %p stub!\n", iface, debugstr_a(name), object);
 489
 490     return E_NOTIMPL;
 491 }
 492
 493 static const ID3DXFileEnumObjectVtbl d3dx9_file_enum_object_vtbl =
 494 {
 495     d3dx9_file_enum_object_QueryInterface,
 496     d3dx9_file_enum_object_AddRef,
 497     d3dx9_file_enum_object_Release,
 498     d3dx9_file_enum_object_GetFile,
 499     d3dx9_file_enum_object_GetChildren,
 500     d3dx9_file_enum_object_GetChild,
 501     d3dx9_file_enum_object_GetDataObjectById,
 502     d3dx9_file_enum_object_GetDataObjectByName,
 503 };
 504
 505 static HRESULT WINAPI d3dx9_file_QueryInterface(ID3DXFile *iface, REFIID riid, void **out)
 506 {
 507     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 508
 509     if (IsEqualGUID(riid, &IID_ID3DXFile)
 510             || IsEqualGUID(riid, &IID_IUnknown))
 511     {
 512         iface->lpVtbl->AddRef(iface);
 513         *out = iface;
 514         return S_OK;
 515     }
 516
 517     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 518
 519     *out = NULL;
 520     return E_NOINTERFACE;
 521 }
 522
 523 static ULONG WINAPI d3dx9_file_AddRef(ID3DXFile *iface)
 524 {
 525     struct d3dx9_file *file = impl_from_ID3DXFile(iface);
 526     ULONG refcount = InterlockedIncrement(&file->ref);
 527
 528     TRACE("%p increasing refcount to %lu.\n", file, refcount);
 529
 530     return refcount;
 531 }
 532
 533 static ULONG WINAPI d3dx9_file_Release(ID3DXFile *iface)
 534 {
 535     struct d3dx9_file *file = impl_from_ID3DXFile(iface);
 536     ULONG refcount = InterlockedDecrement(&file->ref);
 537
 538     TRACE("%p decreasing refcount to %lu.\n", file, refcount);
 539
 540     if (!refcount)
 541     {
 542         IDirectXFile_Release(file->dxfile);
 543         HeapFree(GetProcessHeap(), 0, file);
 544     }
 545
 546     return refcount;
 547 }
 548
 549 static HRESULT WINAPI d3dx9_file_CreateEnumObject(ID3DXFile *iface, const void *source,
 550         D3DXF_FILELOADOPTIONS options, ID3DXFileEnumObject **enum_object)
 551 {
 552     struct d3dx9_file *file = impl_from_ID3DXFile(iface);
 553     struct d3dx9_file_enum_object *object;
 554     IDirectXFileEnumObject *dxfile_enum_object;
 555     void *dxfile_source;
 556     DXFILELOADOPTIONS dxfile_options;
 557     DXFILELOADRESOURCE dxfile_resource;
 558     DXFILELOADMEMORY dxfile_memory;
 559     IDirectXFileData *data_object;
 560     unsigned children_array_size = 0;
 561     HRESULT ret;
 562
 563     TRACE("iface %p, source %p, options %#lx, enum_object %p.\n", iface, source, options, enum_object);
 564
 565     if (!enum_object)
 566         return E_POINTER;
 567
 568     *enum_object = NULL;
 569
 570     if (options == D3DXF_FILELOAD_FROMFILE)
 571     {
 572         dxfile_source = (void*)source;
 573         dxfile_options = DXFILELOAD_FROMFILE;
 574     }
 575     else if (options == D3DXF_FILELOAD_FROMRESOURCE)
 576     {
 577         D3DXF_FILELOADRESOURCE *resource = (D3DXF_FILELOADRESOURCE*)source;
 578
 579         dxfile_resource.hModule = resource->hModule;
 580         dxfile_resource.lpName = resource->lpName;
 581         dxfile_resource.lpType = resource->lpType;
 582         dxfile_source = &dxfile_resource;
 583         dxfile_options = DXFILELOAD_FROMRESOURCE;
 584     }
 585     else if (options == D3DXF_FILELOAD_FROMMEMORY)
 586     {
 587         D3DXF_FILELOADMEMORY *memory = (D3DXF_FILELOADMEMORY*)source;
 588
 589         dxfile_memory.lpMemory = (void *)memory->lpMemory;
 590         dxfile_memory.dSize = memory->dSize;
 591         dxfile_source = &dxfile_memory;
 592         dxfile_options = DXFILELOAD_FROMMEMORY;
 593     }
 594     else
 595     {
 596         FIXME("Source type %lu not handled yet.\n", options);
 597         return E_NOTIMPL;
 598     }
 599
 600     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 601     if (!object)
 602         return E_OUTOFMEMORY;
 603
 604     object->ID3DXFileEnumObject_iface.lpVtbl = &d3dx9_file_enum_object_vtbl;
 605     object->ref = 1;
 606
 607     ret = IDirectXFile_CreateEnumObject(file->dxfile, dxfile_source, dxfile_options, &dxfile_enum_object);
 608
 609     if (ret != S_OK)
 610     {
 611         HeapFree(GetProcessHeap(), 0, object);
 612         return ret;
 613     }
 614
 615     /* Fill enum object with top level data objects */
 616     while (SUCCEEDED(ret = IDirectXFileEnumObject_GetNextDataObject(dxfile_enum_object, &data_object)))
 617     {
 618         if (object->child_count >= children_array_size)
 619         {
 620             ID3DXFileData **new_children;
 621
 622             if (object->children)
 623             {
 624                 children_array_size *= 2;
 625                 new_children = HeapReAlloc(GetProcessHeap(), 0, object->children,
 626                         sizeof(*object->children) * children_array_size);
 627             }
 628             else
 629             {
 630                 children_array_size = 4;
 631                 new_children = HeapAlloc(GetProcessHeap(), 0, sizeof(*object->children) * children_array_size);
 632             }
 633             if (!new_children)
 634             {
 635                 ret = E_OUTOFMEMORY;
 636                 break;
 637             }
 638             object->children = new_children;
 639         }
 640         ret = d3dx9_file_data_create((IDirectXFileObject*)data_object,
 641                 &object->children[object->child_count]);
 642         IUnknown_Release(data_object);
 643         if (FAILED(ret))
 644             break;
 645         ++object->child_count;
 646     }
 647     if (object->children)
 648     {
 649         ID3DXFileData **new_children;
 650
 651         new_children = HeapReAlloc(GetProcessHeap(), 0, object->children,
 652                 sizeof(*object->children) * object->child_count);
 653         if (new_children)
 654             object->children = new_children;
 655     }
 656
 657     IDirectXFileEnumObject_Release(dxfile_enum_object);
 658
 659     if (ret != DXFILEERR_NOMOREOBJECTS)
 660         WARN("Cannot get all top level data objects\n");
 661
 662     TRACE("Found %u children.\n", object->child_count);
 663
 664     *enum_object = &object->ID3DXFileEnumObject_iface;
 665
 666     return S_OK;
 667 }
 668
 669 static HRESULT WINAPI d3dx9_file_CreateSaveObject(ID3DXFile *iface, const void *data,
 670         D3DXF_FILESAVEOPTIONS options, D3DXF_FILEFORMAT format, ID3DXFileSaveObject **save_object)
 671 {
 672     FIXME("iface %p, data %p, options %#lx, format %#lx, save_object %p stub!\n",
 673             iface, data, options, format, save_object);
 674
 675     return E_NOTIMPL;
 676 }
 677
 678 static HRESULT WINAPI d3dx9_file_RegisterTemplates(ID3DXFile *iface, const void *data, SIZE_T size)
 679 {
 680     struct d3dx9_file *file = impl_from_ID3DXFile(iface);
 681     HRESULT ret;
 682
 683     TRACE("iface %p, data %p, size %Iu.\n", iface, data, size);
 684
 685     ret = IDirectXFile_RegisterTemplates(file->dxfile, (void *)data, size);
 686     if (ret != DXFILE_OK)
 687     {
 688         WARN("Error registering templates, hr %#lx.\n", ret);
 689         return error_dxfile_to_d3dxfile(ret);
 690     }
 691
 692     return S_OK;
 693 }
 694
 695 static HRESULT WINAPI d3dx9_file_RegisterEnumTemplates(ID3DXFile *iface, ID3DXFileEnumObject *enum_object)
 696 {
 697     FIXME("iface %p, enum_object %p stub!\n", iface, enum_object);
 698
 699     return E_NOTIMPL;
 700 }
 701
 702 static const ID3DXFileVtbl d3dx9_file_vtbl =
 703 {
 704     d3dx9_file_QueryInterface,
 705     d3dx9_file_AddRef,
 706     d3dx9_file_Release,
 707     d3dx9_file_CreateEnumObject,
 708     d3dx9_file_CreateSaveObject,
 709     d3dx9_file_RegisterTemplates,
 710     d3dx9_file_RegisterEnumTemplates,
 711 };
 712
 713 HRESULT WINAPI D3DXFileCreate(ID3DXFile **d3dxfile)
 714 {
 715     struct d3dx9_file *object;
 716     HRESULT ret;
 717
 718     TRACE("d3dxfile %p.\n", d3dxfile);
 719
 720     if (!d3dxfile)
 721         return E_POINTER;
 722
 723     *d3dxfile = NULL;
 724
 725     object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
 726     if (!object)
 727         return E_OUTOFMEMORY;
 728
 729     ret = DirectXFileCreate(&object->dxfile);
 730     if (ret != S_OK)
 731     {
 732         HeapFree(GetProcessHeap(), 0, object);
 733         if (ret == E_OUTOFMEMORY)
 734             return ret;
 735         return E_FAIL;
 736     }
 737
 738     object->ID3DXFile_iface.lpVtbl = &d3dx9_file_vtbl;
 739     object->ref = 1;
 740
 741     *d3dxfile = &object->ID3DXFile_iface;
 742
 743     return S_OK;
 744 }