dlls/d3dxof/d3dxof.c

   1 /*
   2  * Implementation of DirectX File Interfaces
   3  *
   4  * Copyright 2004, 2008 Christian Costa
   5  *
   6  * This file contains the (internal) driver registration functions,
   7  * driver enumeration APIs and DirectDraw creation functions.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/debug.h"
  26
  27 #define COBJMACROS
  28
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31
  32 #include "d3dxof_private.h"
  33 #include "dxfile.h"
  34
  35 #include <stdio.h>
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(d3dxof);
  38
  39 #define MAKEFOUR(a,b,c,d) ((DWORD)a + ((DWORD)b << 8) + ((DWORD)c << 16) + ((DWORD)d << 24))
  40 #define XOFFILE_FORMAT_MAGIC         MAKEFOUR('x','o','f',' ')
  41 #define XOFFILE_FORMAT_VERSION       MAKEFOUR('0','3','0','2')
  42 #define XOFFILE_FORMAT_BINARY        MAKEFOUR('b','i','n',' ')
  43 #define XOFFILE_FORMAT_TEXT          MAKEFOUR('t','x','t',' ')
  44 #define XOFFILE_FORMAT_COMPRESSED    MAKEFOUR('c','m','p',' ')
  45 #define XOFFILE_FORMAT_FLOAT_BITS_32 MAKEFOUR('0','0','3','2')
  46 #define XOFFILE_FORMAT_FLOAT_BITS_64 MAKEFOUR('0','0','6','4')
  47
  48 #define TOKEN_NAME         1
  49 #define TOKEN_STRING       2
  50 #define TOKEN_INTEGER      3
  51 #define TOKEN_GUID         5
  52 #define TOKEN_INTEGER_LIST 6
  53 #define TOKEN_FLOAT_LIST   7
  54 #define TOKEN_OBRACE      10
  55 #define TOKEN_CBRACE      11
  56 #define TOKEN_OPAREN      12
  57 #define TOKEN_CPAREN      13
  58 #define TOKEN_OBRACKET    14
  59 #define TOKEN_CBRACKET    15
  60 #define TOKEN_OANGLE      16
  61 #define TOKEN_CANGLE      17
  62 #define TOKEN_DOT         18
  63 #define TOKEN_COMMA       19
  64 #define TOKEN_SEMICOLON   20
  65 #define TOKEN_TEMPLATE    31
  66 #define TOKEN_WORD        40
  67 #define TOKEN_DWORD       41
  68 #define TOKEN_FLOAT       42
  69 #define TOKEN_DOUBLE      43
  70 #define TOKEN_CHAR        44
  71 #define TOKEN_UCHAR       45
  72 #define TOKEN_SWORD       46
  73 #define TOKEN_SDWORD      47
  74 #define TOKEN_VOID        48
  75 #define TOKEN_LPSTR       49
  76 #define TOKEN_UNICODE     50
  77 #define TOKEN_CSTRING     51
  78 #define TOKEN_ARRAY       52
  79
  80 #define CLSIDFMT "<%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X>"
  81
  82 typedef struct {
  83   /* Buffer to parse */
  84   LPBYTE buffer;
  85   DWORD rem_bytes;
  86   /* Misc info */
  87   BOOL txt;
  88   BYTE value[100];
  89   IDirectXFileImpl* pdxf;
  90 } parse_buffer;
  91
  92 static const struct IDirectXFileVtbl IDirectXFile_Vtbl;
  93 static const struct IDirectXFileBinaryVtbl IDirectXFileBinary_Vtbl;
  94 static const struct IDirectXFileDataVtbl IDirectXFileData_Vtbl;
  95 static const struct IDirectXFileDataReferenceVtbl IDirectXFileDataReference_Vtbl;
  96 static const struct IDirectXFileEnumObjectVtbl IDirectXFileEnumObject_Vtbl;
  97 static const struct IDirectXFileObjectVtbl IDirectXFileObject_Vtbl;
  98 static const struct IDirectXFileSaveObjectVtbl IDirectXFileSaveObject_Vtbl;
  99
 100 HRESULT IDirectXFileImpl_Create(IUnknown* pUnkOuter, LPVOID* ppObj)
 101 {
 102     IDirectXFileImpl* object;
 103
 104     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 105
 106     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileImpl));
 107
 108     object->lpVtbl.lpVtbl = &IDirectXFile_Vtbl;
 109     object->ref = 1;
 110
 111     *ppObj = object;
 112
 113     return S_OK;
 114 }
 115
 116 /*** IUnknown methods ***/
 117 static HRESULT WINAPI IDirectXFileImpl_QueryInterface(IDirectXFile* iface, REFIID riid, void** ppvObject)
 118 {
 119   IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
 120
 121   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
 122
 123   if (IsEqualGUID(riid, &IID_IUnknown)
 124       || IsEqualGUID(riid, &IID_IDirectXFile))
 125   {
 126     IClassFactory_AddRef(iface);
 127     *ppvObject = This;
 128     return S_OK;
 129   }
 130
 131   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
 132   return E_NOINTERFACE;
 133 }
 134
 135 static ULONG WINAPI IDirectXFileImpl_AddRef(IDirectXFile* iface)
 136 {
 137   IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
 138   ULONG ref = InterlockedIncrement(&This->ref);
 139
 140   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
 141
 142   return ref;
 143 }
 144
 145 static ULONG WINAPI IDirectXFileImpl_Release(IDirectXFile* iface)
 146 {
 147   IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
 148   ULONG ref = InterlockedDecrement(&This->ref);
 149
 150   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
 151
 152   if (!ref)
 153     HeapFree(GetProcessHeap(), 0, This);
 154
 155   return ref;
 156 }
 157
 158 /*** IDirectXFile methods ***/
 159 static HRESULT WINAPI IDirectXFileImpl_CreateEnumObject(IDirectXFile* iface, LPVOID pvSource, DXFILELOADOPTIONS dwLoadOptions, LPDIRECTXFILEENUMOBJECT* ppEnumObj)
 160 {
 161   IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
 162   IDirectXFileEnumObjectImpl* object;
 163   HRESULT hr;
 164
 165   FIXME("(%p/%p)->(%p,%x,%p) stub!\n", This, iface, pvSource, dwLoadOptions, ppEnumObj);
 166
 167   if (dwLoadOptions == DXFILELOAD_FROMFILE)
 168   {
 169     HANDLE hFile;
 170     TRACE("Open source file '%s'\n", (char*)pvSource);
 171     hFile = CreateFileA((char*)pvSource, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 172     if (hFile == INVALID_HANDLE_VALUE)
 173     {
 174       TRACE("File '%s' not found\n", (char*)pvSource);
 175       return DXFILEERR_FILENOTFOUND;
 176     }
 177     CloseHandle(hFile);
 178   }
 179   else
 180   {
 181     FIXME("Source type %d is not handled yet\n", dwLoadOptions);
 182   }
 183
 184   hr = IDirectXFileEnumObjectImpl_Create(&object);
 185   if (!SUCCEEDED(hr))
 186     return hr;
 187
 188   *ppEnumObj = (LPDIRECTXFILEENUMOBJECT)object;
 189
 190   return DXFILE_OK;
 191 }
 192
 193 static HRESULT WINAPI IDirectXFileImpl_CreateSaveObject(IDirectXFile* iface, LPCSTR szFileName, DXFILEFORMAT dwFileFormat, LPDIRECTXFILESAVEOBJECT* ppSaveObj)
 194 {
 195   IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
 196
 197   FIXME("(%p/%p)->(%s,%x,%p) stub!\n", This, iface, szFileName, dwFileFormat, ppSaveObj);
 198
 199   return DXFILEERR_BADVALUE;
 200 }
 201
 202 static BOOL read_bytes(parse_buffer * buf, LPVOID data, DWORD size)
 203 {
 204   if (buf->rem_bytes < size)
 205     return FALSE;
 206   memcpy(data, buf->buffer, size);
 207   buf->buffer += size;
 208   buf->rem_bytes -= size;
 209   return TRUE;
 210 }
 211
 212 static void dump_TOKEN(WORD token)
 213 {
 214 #define DUMP_TOKEN(t) case t: TRACE(#t "\n"); break
 215   switch(token)
 216   {
 217     DUMP_TOKEN(TOKEN_NAME);
 218     DUMP_TOKEN(TOKEN_STRING);
 219     DUMP_TOKEN(TOKEN_INTEGER);
 220     DUMP_TOKEN(TOKEN_GUID);
 221     DUMP_TOKEN(TOKEN_INTEGER_LIST);
 222     DUMP_TOKEN(TOKEN_FLOAT_LIST);
 223     DUMP_TOKEN(TOKEN_OBRACE);
 224     DUMP_TOKEN(TOKEN_CBRACE);
 225     DUMP_TOKEN(TOKEN_OPAREN);
 226     DUMP_TOKEN(TOKEN_CPAREN);
 227     DUMP_TOKEN(TOKEN_OBRACKET);
 228     DUMP_TOKEN(TOKEN_CBRACKET);
 229     DUMP_TOKEN(TOKEN_OANGLE);
 230     DUMP_TOKEN(TOKEN_CANGLE);
 231     DUMP_TOKEN(TOKEN_DOT);
 232     DUMP_TOKEN(TOKEN_COMMA);
 233     DUMP_TOKEN(TOKEN_SEMICOLON);
 234     DUMP_TOKEN(TOKEN_TEMPLATE);
 235     DUMP_TOKEN(TOKEN_WORD);
 236     DUMP_TOKEN(TOKEN_DWORD);
 237     DUMP_TOKEN(TOKEN_FLOAT);
 238     DUMP_TOKEN(TOKEN_DOUBLE);
 239     DUMP_TOKEN(TOKEN_CHAR);
 240     DUMP_TOKEN(TOKEN_UCHAR);
 241     DUMP_TOKEN(TOKEN_SWORD);
 242     DUMP_TOKEN(TOKEN_SDWORD);
 243     DUMP_TOKEN(TOKEN_VOID);
 244     DUMP_TOKEN(TOKEN_LPSTR);
 245     DUMP_TOKEN(TOKEN_UNICODE);
 246     DUMP_TOKEN(TOKEN_CSTRING);
 247     DUMP_TOKEN(TOKEN_ARRAY);
 248     default:
 249       if (0)
 250         TRACE("Unknown token %d\n", token);
 251       break;
 252   }
 253 #undef DUMP_TOKEN
 254 }
 255
 256 static BOOL is_space(char c)
 257 {
 258   switch (c)
 259   {
 260     case 0x00:
 261     case 0x0D:
 262     case 0x0A:
 263     case ' ':
 264     case '\t':
 265       return TRUE;
 266   }
 267   return FALSE;
 268 }
 269
 270 static BOOL is_operator(char c)
 271 {
 272   switch(c)
 273   {
 274     case '{':
 275     case '}':
 276     case '[':
 277     case ']':
 278     case '(':
 279     case ')':
 280     case '<':
 281     case '>':
 282     case ',':
 283     case ';':
 284       return TRUE;
 285   }
 286   return FALSE;
 287 }
 288
 289 static inline BOOL is_separator(char c)
 290 {
 291   return is_space(c) || is_operator(c);
 292 }
 293
 294 static WORD get_operator_token(char c)
 295 {
 296   switch(c)
 297   {
 298     case '{':
 299       return TOKEN_OBRACE;
 300     case '}':
 301       return TOKEN_CBRACE;
 302     case '[':
 303       return TOKEN_OBRACKET;
 304     case ']':
 305       return TOKEN_CBRACKET;
 306     case '(':
 307       return TOKEN_OPAREN;
 308     case ')':
 309       return TOKEN_CPAREN;
 310     case '<':
 311       return TOKEN_OANGLE;
 312     case '>':
 313       return TOKEN_CANGLE;
 314     case ',':
 315       return TOKEN_COMMA;
 316     case ';':
 317       return TOKEN_SEMICOLON;
 318   }
 319   return 0;
 320 }
 321
 322 static BOOL is_keyword(parse_buffer* buf, const char* keyword)
 323 {
 324   DWORD len = strlen(keyword);
 325   if (!strncmp((char*)buf->buffer, keyword,len) && is_separator(*(buf->buffer+len)))
 326   {
 327     buf->buffer += len;
 328     buf->rem_bytes -= len;
 329     return TRUE;
 330   }
 331   return FALSE;
 332 }
 333
 334 static WORD get_keyword_token(parse_buffer* buf)
 335 {
 336   if (is_keyword(buf, "template"))
 337     return TOKEN_TEMPLATE;
 338   if (is_keyword(buf, "WORD"))
 339     return TOKEN_WORD;
 340   if (is_keyword(buf, "DWORD"))
 341     return TOKEN_DWORD;
 342   if (is_keyword(buf, "FLOAT"))
 343     return TOKEN_FLOAT;
 344   if (is_keyword(buf, "DOUBLE"))
 345     return TOKEN_DOUBLE;
 346   if (is_keyword(buf, "CHAR"))
 347     return TOKEN_CHAR;
 348   if (is_keyword(buf, "UCHAR"))
 349     return TOKEN_UCHAR;
 350   if (is_keyword(buf, "SWORD"))
 351     return TOKEN_SWORD;
 352   if (is_keyword(buf, "SDWORD"))
 353     return TOKEN_SDWORD;
 354   if (is_keyword(buf, "VOID"))
 355     return TOKEN_VOID;
 356   if (is_keyword(buf, "LPSTR"))
 357     return TOKEN_LPSTR;
 358   if (is_keyword(buf, "UNICODE"))
 359     return TOKEN_UNICODE;
 360   if (is_keyword(buf, "CSTRING"))
 361     return TOKEN_CSTRING;
 362   if (is_keyword(buf, "array"))
 363     return TOKEN_ARRAY;
 364
 365   return 0;
 366 }
 367
 368 static BOOL is_guid(parse_buffer* buf)
 369 {
 370   char tmp[50];
 371   DWORD pos = 1;
 372   GUID class_id;
 373   DWORD tab[10];
 374   int ret;
 375
 376   if (*buf->buffer != '<')
 377     return FALSE;
 378   tmp[0] = '<';
 379   while (*(buf->buffer+pos) != '>')
 380   {
 381     tmp[pos] = *(buf->buffer+pos);
 382     pos++;
 383   }
 384   tmp[pos++] = '>';
 385   tmp[pos] = 0;
 386   if (pos != 38 /* <+36+> */)
 387   {
 388     TRACE("Wrong guid %s (%d) \n", tmp, pos);
 389     return FALSE;
 390   }
 391   buf->buffer += pos;
 392   buf->rem_bytes -= pos;
 393
 394   ret = sscanf(tmp, CLSIDFMT, &class_id.Data1, tab, tab+1, tab+2, tab+3, tab+4, tab+5, tab+6, tab+7, tab+8, tab+9);
 395   if (ret != 11)
 396   {
 397     TRACE("Wrong guid %s (%d) \n", tmp, pos);
 398     return FALSE;
 399   }
 400   TRACE("Found guid %s (%d) \n", tmp, pos);
 401
 402   class_id.Data2 = tab[0];
 403   class_id.Data3 = tab[1];
 404   class_id.Data4[0] = tab[2];
 405   class_id.Data4[1] = tab[3];
 406   class_id.Data4[2] = tab[4];
 407   class_id.Data4[3] = tab[5];
 408   class_id.Data4[4] = tab[6];
 409   class_id.Data4[5] = tab[7];
 410   class_id.Data4[6] = tab[8];
 411   class_id.Data4[7] = tab[9];
 412
 413   *(GUID*)buf->value = class_id;
 414
 415   return TRUE;
 416 }
 417
 418 static BOOL is_name(parse_buffer* buf)
 419 {
 420   char tmp[50];
 421   DWORD pos = 0;
 422   char c;
 423   BOOL error = 0;
 424   while (!is_separator(c = *(buf->buffer+pos)))
 425   {
 426     if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))))
 427       error = 1;
 428     tmp[pos++] = c;
 429   }
 430   tmp[pos] = 0;
 431
 432   if (error)
 433   {
 434     TRACE("Wrong name %s\n", tmp);
 435     return FALSE;
 436   }
 437
 438   buf->buffer += pos;
 439   buf->rem_bytes -= pos;
 440
 441   TRACE("Found name %s\n", tmp);
 442   strcpy((char*)buf->value, tmp);
 443
 444   return TRUE;
 445 }
 446
 447 static BOOL is_integer(parse_buffer* buf)
 448 {
 449   char tmp[50];
 450   DWORD pos = 0;
 451   char c;
 452   DWORD integer;
 453
 454   while (!is_separator(c = *(buf->buffer+pos)))
 455   {
 456     if (!((c >= '0') && (c <= '9')))
 457       return FALSE;
 458     tmp[pos++] = c;
 459   }
 460   tmp[pos] = 0;
 461
 462   buf->buffer += pos;
 463   buf->rem_bytes -= pos;
 464
 465   sscanf(tmp, "%d", &integer);
 466
 467   TRACE("Found integer %s - %d\n", tmp, integer);
 468
 469   *(WORD*)buf->value = integer;
 470
 471   return TRUE;
 472 }
 473
 474 static WORD parse_TOKEN_dbg_opt(parse_buffer * buf, BOOL show_token)
 475 {
 476   WORD token;
 477
 478   if (buf->txt)
 479   {
 480     while(1)
 481     {
 482       char c;
 483       if (!read_bytes(buf, &c, 1))
 484         return 0;
 485       /*TRACE("char = '%c'\n", is_space(c) ? ' ' : c);*/
 486       if (is_space(c))
 487         continue;
 488       if (is_operator(c) && (c != '<'))
 489       {
 490         token = get_operator_token(c);
 491         break;
 492       }
 493       else if (c == '.')
 494       {
 495         token = TOKEN_DOT;
 496         break;
 497       }
 498       else
 499       {
 500         buf->buffer -= 1;
 501         buf->rem_bytes += 1;
 502
 503         if ((token = get_keyword_token(buf)))
 504           break;
 505
 506         if (is_guid(buf))
 507         {
 508           token = TOKEN_GUID;
 509           break;
 510         }
 511         if (is_integer(buf))
 512         {
 513           token = TOKEN_INTEGER;
 514           break;
 515         }
 516         if (is_name(buf))
 517         {
 518           token = TOKEN_NAME;
 519           break;
 520         }
 521
 522         FIXME("Unrecognize element\n");
 523         return 0;
 524       }
 525     }
 526   }
 527   else
 528   {
 529     if (!read_bytes(buf, &token, 2))
 530       return 0;
 531   }
 532
 533   switch(token)
 534   {
 535     case TOKEN_NAME:
 536     case TOKEN_STRING:
 537     case TOKEN_INTEGER:
 538     case TOKEN_GUID:
 539     case TOKEN_INTEGER_LIST:
 540     case TOKEN_FLOAT_LIST:
 541     case TOKEN_OBRACE:
 542     case TOKEN_CBRACE:
 543     case TOKEN_OPAREN:
 544     case TOKEN_CPAREN:
 545     case TOKEN_OBRACKET:
 546     case TOKEN_CBRACKET:
 547     case TOKEN_OANGLE:
 548     case TOKEN_CANGLE:
 549     case TOKEN_DOT:
 550     case TOKEN_COMMA:
 551     case TOKEN_SEMICOLON:
 552     case TOKEN_TEMPLATE:
 553     case TOKEN_WORD:
 554     case TOKEN_DWORD:
 555     case TOKEN_FLOAT:
 556     case TOKEN_DOUBLE:
 557     case TOKEN_CHAR:
 558     case TOKEN_UCHAR:
 559     case TOKEN_SWORD:
 560     case TOKEN_SDWORD:
 561     case TOKEN_VOID:
 562     case TOKEN_LPSTR:
 563     case TOKEN_UNICODE:
 564     case TOKEN_CSTRING:
 565     case TOKEN_ARRAY:
 566       break;
 567     default:
 568       return 0;
 569   }
 570
 571   if (show_token)
 572     dump_TOKEN(token);
 573
 574   return token;
 575 }
 576
 577 static const char* get_primitive_string(WORD token)
 578 {
 579   switch(token)
 580   {
 581     case TOKEN_WORD:
 582       return "WORD";
 583     case TOKEN_DWORD:
 584       return "DWORD";
 585     case TOKEN_FLOAT:
 586       return "FLOAT";
 587     case TOKEN_DOUBLE:
 588       return "DOUBLE";
 589     case TOKEN_CHAR:
 590       return "CHAR";
 591     case TOKEN_UCHAR:
 592       return "UCHAR";
 593     case TOKEN_SWORD:
 594       return "SWORD";
 595     case TOKEN_SDWORD:
 596       return "SDWORD";
 597     case TOKEN_VOID:
 598       return "VOID";
 599     case TOKEN_LPSTR:
 600       return "LPSTR";
 601     case TOKEN_UNICODE:
 602       return "UNICODE";
 603     case TOKEN_CSTRING:
 604       return "CSTRING ";
 605     default:
 606       break;
 607   }
 608   return NULL;
 609 }
 610
 611 static inline WORD parse_TOKEN(parse_buffer * buf)
 612 {
 613   return parse_TOKEN_dbg_opt(buf, TRUE);
 614 }
 615
 616 static WORD check_TOKEN(parse_buffer * buf)
 617 {
 618   WORD token;
 619
 620   if (buf->txt)
 621   {
 622     parse_buffer save = *buf;
 623     /*TRACE("check: ");*/
 624     token = parse_TOKEN_dbg_opt(buf, FALSE);
 625     *buf = save;
 626     return token;
 627   }
 628
 629   if (!read_bytes(buf, &token, 2))
 630     return 0;
 631   buf->buffer -= 2;
 632   buf->rem_bytes += 2;
 633   if (0)
 634   {
 635     TRACE("check: ");
 636     dump_TOKEN(token);
 637   }
 638   return token;
 639 }
 640
 641 static inline BOOL is_primitive_type(WORD token)
 642 {
 643   BOOL ret;
 644   switch(token)
 645   {
 646     case TOKEN_WORD:
 647     case TOKEN_DWORD:
 648     case TOKEN_FLOAT:
 649     case TOKEN_DOUBLE:
 650     case TOKEN_CHAR:
 651     case TOKEN_UCHAR:
 652     case TOKEN_SWORD:
 653     case TOKEN_SDWORD:
 654     case TOKEN_LPSTR:
 655     case TOKEN_UNICODE:
 656     case TOKEN_CSTRING:
 657       ret = 1;
 658       break;
 659     default:
 660       ret = 0;
 661       break;
 662   }
 663   return ret;
 664 }
 665
 666 static BOOL parse_name(parse_buffer * buf)
 667 {
 668   DWORD count;
 669   char strname[100];
 670
 671   if (parse_TOKEN(buf) != TOKEN_NAME)
 672     return FALSE;
 673   if (buf->txt)
 674     return TRUE;
 675   if (!read_bytes(buf, &count, 4))
 676     return FALSE;
 677   if (!read_bytes(buf, strname, count))
 678     return FALSE;
 679   strname[count] = 0;
 680   /*TRACE("name = %s\n", strname);*/
 681
 682   strcpy((char*)buf->value, strname);
 683
 684   return TRUE;
 685 }
 686
 687 static BOOL parse_class_id(parse_buffer * buf)
 688 {
 689   char strguid[38];
 690   GUID class_id;
 691
 692   if (parse_TOKEN(buf) != TOKEN_GUID)
 693     return FALSE;
 694   if (buf->txt)
 695     return TRUE;
 696   if (!read_bytes(buf, &class_id, 16))
 697     return FALSE;
 698   sprintf(strguid, CLSIDFMT, class_id.Data1, class_id.Data2, class_id.Data3, class_id.Data4[0],
 699     class_id.Data4[1], class_id.Data4[2], class_id.Data4[3], class_id.Data4[4], class_id.Data4[5], class_id.Data4[6], class_id.Data4[7]);
 700   /*TRACE("guid = {%s}\n", strguid);*/
 701
 702   *(GUID*)buf->value = class_id;
 703
 704   return TRUE;
 705 }
 706
 707 static BOOL parse_integer(parse_buffer * buf)
 708 {
 709   DWORD integer;
 710
 711   if (parse_TOKEN(buf) != TOKEN_INTEGER)
 712     return FALSE;
 713   if (buf->txt)
 714     return TRUE;
 715   if (!read_bytes(buf, &integer, 4))
 716     return FALSE;
 717   /*TRACE("integer = %ld\n", integer);*/
 718
 719   *(DWORD*)buf->value = integer;
 720
 721   return TRUE;
 722 }
 723
 724 static BOOL parse_template_option_info(parse_buffer * buf)
 725 {
 726   xtemplate* cur_template = &buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates];
 727
 728   if (check_TOKEN(buf) == TOKEN_DOT)
 729   {
 730     parse_TOKEN(buf);
 731     if (parse_TOKEN(buf) != TOKEN_DOT)
 732       return FALSE;
 733     if (parse_TOKEN(buf) != TOKEN_DOT)
 734       return FALSE;
 735     cur_template->open = TRUE;
 736   }
 737   else
 738   {
 739     while (1)
 740     {
 741       if (!parse_name(buf))
 742         return FALSE;
 743       strcpy(cur_template->childs[cur_template->nb_childs], (char*)buf->value);
 744       if (check_TOKEN(buf) == TOKEN_GUID)
 745         if (!parse_class_id(buf))
 746           return FALSE;
 747       cur_template->nb_childs++;
 748       if (check_TOKEN(buf) != TOKEN_COMMA)
 749         break;
 750       parse_TOKEN(buf);
 751     }
 752     cur_template->open = FALSE;
 753   }
 754
 755   return TRUE;
 756 }
 757
 758 static BOOL parse_template_members_list(parse_buffer * buf)
 759 {
 760   parse_buffer save1;
 761   int idx_member = 0;
 762   member* cur_member;
 763
 764   while (1)
 765   {
 766     cur_member = &buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].members[idx_member];
 767     save1 = *buf;
 768
 769     if (check_TOKEN(buf) == TOKEN_NAME)
 770     {
 771       if (!parse_name(buf))
 772         break;
 773       while (cur_member->idx_template < buf->pdxf->nb_xtemplates)
 774       {
 775         if (!strcmp((char*)buf->value, buf->pdxf->xtemplates[cur_member->idx_template].name))
 776           break;
 777         cur_member->idx_template++;
 778       }
 779       if (cur_member->idx_template == buf->pdxf->nb_xtemplates)
 780       {
 781         TRACE("Reference to non existing template '%s'\n", (char*)buf->value);
 782         return FALSE;
 783       }
 784       if (check_TOKEN(buf) == TOKEN_NAME)
 785         if (!parse_name(buf))
 786           break;
 787       if (parse_TOKEN(buf) != TOKEN_SEMICOLON)
 788         break;
 789       cur_member->type = TOKEN_NAME;
 790       strcpy(cur_member->name, (char*)buf->value);
 791       idx_member++;
 792     }
 793     else if (check_TOKEN(buf) == TOKEN_ARRAY)
 794     {
 795       parse_buffer save2;
 796       WORD token;
 797       int nb_dims = 0;
 798
 799       parse_TOKEN(buf);
 800       token = check_TOKEN(buf);
 801       if (is_primitive_type(token))
 802       {
 803         parse_TOKEN(buf);
 804         cur_member->type = token;
 805       }
 806       else
 807       {
 808         if (!parse_name(buf))
 809           break;
 810         cur_member->type = TOKEN_NAME;
 811         cur_member->idx_template = 0;
 812         while (cur_member->idx_template < buf->pdxf->nb_xtemplates)
 813         {
 814           if (!strcmp((char*)buf->value, buf->pdxf->xtemplates[cur_member->idx_template].name))
 815             break;
 816           cur_member->idx_template++;
 817         }
 818         if (cur_member->idx_template == buf->pdxf->nb_xtemplates)
 819         {
 820           TRACE("Reference to non existing template '%s'\n", (char*)buf->value);
 821           return FALSE;
 822         }
 823       }
 824       if (!parse_name(buf))
 825         break;
 826       strcpy(cur_member->name, (char*)buf->value);
 827       save2 = *buf;
 828       while (check_TOKEN(buf) == TOKEN_OBRACKET)
 829       {
 830         if (nb_dims)
 831         {
 832           FIXME("No support for multi-dimensional array yet\n");
 833           return FALSE;
 834         }
 835         parse_TOKEN(buf);
 836         if (check_TOKEN(buf) == TOKEN_INTEGER)
 837         {
 838           if (!parse_integer(buf))
 839             break;
 840           cur_member->dim_fixed[nb_dims] = TRUE;
 841           cur_member->dim_value[nb_dims] = *(DWORD*)buf->value;
 842         }
 843         else
 844         {
 845           if (!parse_name(buf))
 846             break;
 847           cur_member->dim_fixed[nb_dims] = FALSE;
 848           /* Hack: Assume array size is specified in previous member */
 849           cur_member->dim_value[nb_dims] = idx_member - 1;
 850         }
 851         if (parse_TOKEN(buf) != TOKEN_CBRACKET)
 852           break;
 853         save2 = *buf;
 854         nb_dims++;
 855       }
 856       *buf = save2;
 857       if (parse_TOKEN(buf) != TOKEN_SEMICOLON)
 858         break;
 859       cur_member->nb_dims = nb_dims;
 860       idx_member++;
 861     }
 862     else if (is_primitive_type(check_TOKEN(buf)))
 863     {
 864       cur_member->type = check_TOKEN(buf);
 865       parse_TOKEN(buf);
 866       if (check_TOKEN(buf) == TOKEN_NAME)
 867         if (!parse_name(buf))
 868           break;
 869       strcpy(cur_member->name, (char*)buf->value);
 870       if (parse_TOKEN(buf) != TOKEN_SEMICOLON)
 871         break;
 872       idx_member++;
 873     }
 874     else
 875       break;
 876   }
 877
 878   *buf = save1;
 879   buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].nb_members = idx_member;
 880
 881   return TRUE;
 882 }
 883
 884 static BOOL parse_template_parts(parse_buffer * buf)
 885 {
 886   if (check_TOKEN(buf) == TOKEN_OBRACKET)
 887   {
 888     parse_TOKEN(buf);
 889     if (!parse_template_option_info(buf))
 890       return FALSE;
 891     if (parse_TOKEN(buf) != TOKEN_CBRACKET)
 892       return FALSE;
 893   }
 894   else
 895   {
 896     if (!parse_template_members_list(buf))
 897       return FALSE;
 898     if (check_TOKEN(buf) == TOKEN_OBRACKET)
 899     {
 900       parse_TOKEN(buf);
 901       if (!parse_template_option_info(buf))
 902         return FALSE;
 903       if (parse_TOKEN(buf) != TOKEN_CBRACKET)
 904        return FALSE;
 905     }
 906   }
 907
 908   return TRUE;
 909 }
 910
 911 static BOOL parse_template(parse_buffer * buf)
 912 {
 913   if (parse_TOKEN(buf) != TOKEN_TEMPLATE)
 914     return FALSE;
 915   if (!parse_name(buf))
 916     return FALSE;
 917   strcpy(buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].name, (char*)buf->value);
 918   if (parse_TOKEN(buf) != TOKEN_OBRACE)
 919     return FALSE;
 920   if (!parse_class_id(buf))
 921     return FALSE;
 922   buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].class_id = *(GUID*)buf->value;
 923   if (!parse_template_parts(buf))
 924     return FALSE;
 925   if (parse_TOKEN(buf) != TOKEN_CBRACE)
 926     return FALSE;
 927   if (buf->txt)
 928   {
 929     /* Go to the next template */
 930     while (buf->rem_bytes)
 931     {
 932       if (is_space(*buf->buffer))
 933       {
 934         buf->buffer++;
 935         buf->rem_bytes--;
 936       }
 937     }
 938   }
 939
 940   TRACE("%d - %s - %s\n", buf->pdxf->nb_xtemplates, buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].name, debugstr_guid(&buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].class_id));
 941   buf->pdxf->nb_xtemplates++;
 942
 943   return TRUE;
 944 }
 945
 946 static HRESULT WINAPI IDirectXFileImpl_RegisterTemplates(IDirectXFile* iface, LPVOID pvData, DWORD cbSize)
 947 {
 948   IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
 949   DWORD token_header;
 950   parse_buffer buf;
 951
 952   buf.buffer = (LPBYTE)pvData;
 953   buf.rem_bytes = cbSize;
 954   buf.txt = FALSE;
 955   buf.pdxf = This;
 956
 957   FIXME("(%p/%p)->(%p,%d) partial stub!\n", This, iface, pvData, cbSize);
 958
 959   if (!pvData)
 960     return DXFILEERR_BADVALUE;
 961
 962   if (cbSize < 16)
 963     return DXFILEERR_BADFILETYPE;
 964
 965   if (TRACE_ON(d3dxof))
 966   {
 967     char string[17];
 968     memcpy(string, pvData, 16);
 969     string[16] = 0;
 970     TRACE("header = '%s'\n", string);
 971   }
 972
 973   read_bytes(&buf, &token_header, 4);
 974
 975   if (token_header != XOFFILE_FORMAT_MAGIC)
 976     return DXFILEERR_BADFILETYPE;
 977
 978   read_bytes(&buf, &token_header, 4);
 979
 980   if (token_header != XOFFILE_FORMAT_VERSION)
 981     return DXFILEERR_BADFILEVERSION;
 982
 983   read_bytes(&buf, &token_header, 4);
 984
 985   if ((token_header != XOFFILE_FORMAT_BINARY) && (token_header != XOFFILE_FORMAT_TEXT) && (token_header != XOFFILE_FORMAT_COMPRESSED))
 986     return DXFILEERR_BADFILETYPE;
 987
 988   if (token_header == XOFFILE_FORMAT_TEXT)
 989   {
 990     buf.txt = TRUE;
 991   }
 992
 993   if (token_header == XOFFILE_FORMAT_COMPRESSED)
 994   {
 995     FIXME("Compressed formats not supported yet");
 996     return DXFILEERR_BADVALUE;
 997   }
 998
 999   read_bytes(&buf, &token_header, 4);
1000
1001   if ((token_header != XOFFILE_FORMAT_FLOAT_BITS_32) && (token_header != XOFFILE_FORMAT_FLOAT_BITS_64))
1002     return DXFILEERR_BADFILEFLOATSIZE;
1003
1004   TRACE("Header is correct\n");
1005
1006   while (buf.rem_bytes)
1007   {
1008     if (!parse_template(&buf))
1009     {
1010       TRACE("Template is not correct\n");
1011       return DXFILEERR_BADVALUE;
1012     }
1013     else
1014     {
1015       TRACE("Template successfully parsed:\n");
1016       if (TRACE_ON(d3dxof))
1017       {
1018         int i,j,k;
1019         GUID* clsid;
1020
1021         i = This->nb_xtemplates - 1;
1022         clsid = &This->xtemplates[i].class_id;
1023
1024         DPRINTF("template %s {\n", This->xtemplates[i].name);
1025         DPRINTF(CLSIDFMT "\n", clsid->Data1, clsid->Data2, clsid->Data3, clsid->Data4[0],
1026           clsid->Data4[1], clsid->Data4[2], clsid->Data4[3], clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7]);
1027         for (j = 0; j < This->xtemplates[i].nb_members; j++)
1028         {
1029           if (This->xtemplates[i].members[j].nb_dims)
1030             DPRINTF("array ");
1031           if (This->xtemplates[i].members[j].type == TOKEN_NAME)
1032             DPRINTF("%s ", This->xtemplates[This->xtemplates[i].members[j].idx_template].name);
1033           else
1034             DPRINTF("%s ", get_primitive_string(This->xtemplates[i].members[j].type));
1035           DPRINTF("%s", This->xtemplates[i].members[j].name);
1036           for (k = 0; k < This->xtemplates[i].members[j].nb_dims; k++)
1037           {
1038             if (This->xtemplates[i].members[j].dim_fixed[k])
1039               DPRINTF("[%d]", This->xtemplates[i].members[j].dim_value[k]);
1040             else
1041               DPRINTF("[%s]", This->xtemplates[i].members[This->xtemplates[i].members[j].dim_value[k]].name);
1042           }
1043           DPRINTF(";\n");
1044         }
1045         if (This->xtemplates[i].open)
1046           DPRINTF("[...]\n");
1047         else if (This->xtemplates[i].nb_childs)
1048         {
1049           DPRINTF("[%s", This->xtemplates[i].childs[0]);
1050           for (j = 1; j < This->xtemplates[i].nb_childs; j++)
1051             DPRINTF(",%s", This->xtemplates[i].childs[j]);
1052           DPRINTF("]\n");
1053         }
1054         DPRINTF("}\n");
1055       }
1056     }
1057   }
1058
1059   if (TRACE_ON(d3dxof))
1060   {
1061     int i;
1062     TRACE("Registered templates (%d):\n", This->nb_xtemplates);
1063     for (i = 0; i < This->nb_xtemplates; i++)
1064       DPRINTF("%s - %s\n", This->xtemplates[i].name, debugstr_guid(&This->xtemplates[i].class_id));
1065   }
1066
1067   return DXFILE_OK;
1068 }
1069
1070 static const IDirectXFileVtbl IDirectXFile_Vtbl =
1071 {
1072   IDirectXFileImpl_QueryInterface,
1073   IDirectXFileImpl_AddRef,
1074   IDirectXFileImpl_Release,
1075   IDirectXFileImpl_CreateEnumObject,
1076   IDirectXFileImpl_CreateSaveObject,
1077   IDirectXFileImpl_RegisterTemplates
1078 };
1079
1080 HRESULT IDirectXFileBinaryImpl_Create(IDirectXFileBinaryImpl** ppObj)
1081 {
1082     IDirectXFileBinaryImpl* object;
1083
1084     TRACE("(%p)\n", ppObj);
1085
1086     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileBinaryImpl));
1087
1088     object->lpVtbl.lpVtbl = &IDirectXFileBinary_Vtbl;
1089     object->ref = 1;
1090
1091     *ppObj = object;
1092
1093     return DXFILE_OK;
1094 }
1095
1096 /*** IUnknown methods ***/
1097 static HRESULT WINAPI IDirectXFileBinaryImpl_QueryInterface(IDirectXFileBinary* iface, REFIID riid, void** ppvObject)
1098 {
1099   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1100
1101   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1102
1103   if (IsEqualGUID(riid, &IID_IUnknown)
1104       || IsEqualGUID(riid, &IID_IDirectXFileObject)
1105       || IsEqualGUID(riid, &IID_IDirectXFileBinary))
1106   {
1107     IClassFactory_AddRef(iface);
1108     *ppvObject = This;
1109     return S_OK;
1110   }
1111
1112   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1113   return E_NOINTERFACE;
1114 }
1115
1116 static ULONG WINAPI IDirectXFileBinaryImpl_AddRef(IDirectXFileBinary* iface)
1117 {
1118   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1119   ULONG ref = InterlockedIncrement(&This->ref);
1120
1121   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1122
1123   return ref;
1124 }
1125
1126 static ULONG WINAPI IDirectXFileBinaryImpl_Release(IDirectXFileBinary* iface)
1127 {
1128   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1129   ULONG ref = InterlockedDecrement(&This->ref);
1130
1131   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1132
1133   if (!ref)
1134     HeapFree(GetProcessHeap(), 0, This);
1135
1136   return ref;
1137 }
1138
1139 /*** IDirectXFileObject methods ***/
1140 static HRESULT WINAPI IDirectXFileBinaryImpl_GetName(IDirectXFileBinary* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1141
1142 {
1143   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1144
1145   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1146
1147   return DXFILEERR_BADVALUE;
1148 }
1149
1150 static HRESULT WINAPI IDirectXFileBinaryImpl_GetId(IDirectXFileBinary* iface, LPGUID pGuid)
1151 {
1152   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1153
1154   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1155
1156   return DXFILEERR_BADVALUE;
1157 }
1158
1159 /*** IDirectXFileBinary methods ***/
1160 static HRESULT WINAPI IDirectXFileBinaryImpl_GetSize(IDirectXFileBinary* iface, DWORD* pcbSize)
1161 {
1162   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1163
1164   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pcbSize);
1165
1166   return DXFILEERR_BADVALUE;
1167 }
1168
1169 static HRESULT WINAPI IDirectXFileBinaryImpl_GetMimeType(IDirectXFileBinary* iface, LPCSTR* pszMimeType)
1170 {
1171   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1172
1173   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pszMimeType);
1174
1175   return DXFILEERR_BADVALUE;
1176 }
1177
1178 static HRESULT WINAPI IDirectXFileBinaryImpl_Read(IDirectXFileBinary* iface, LPVOID pvData, DWORD cbSize, LPDWORD pcbRead)
1179 {
1180   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1181
1182   FIXME("(%p/%p)->(%p, %d, %p) stub!\n", This, iface, pvData, cbSize, pcbRead);
1183
1184   return DXFILEERR_BADVALUE;
1185 }
1186
1187 static const IDirectXFileBinaryVtbl IDirectXFileBinary_Vtbl =
1188 {
1189     IDirectXFileBinaryImpl_QueryInterface,
1190     IDirectXFileBinaryImpl_AddRef,
1191     IDirectXFileBinaryImpl_Release,
1192     IDirectXFileBinaryImpl_GetName,
1193     IDirectXFileBinaryImpl_GetId,
1194     IDirectXFileBinaryImpl_GetSize,
1195     IDirectXFileBinaryImpl_GetMimeType,
1196     IDirectXFileBinaryImpl_Read
1197 };
1198
1199 HRESULT IDirectXFileDataImpl_Create(IDirectXFileDataImpl** ppObj)
1200 {
1201     IDirectXFileDataImpl* object;
1202
1203     TRACE("(%p)\n", ppObj);
1204
1205     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataImpl));
1206
1207     object->lpVtbl.lpVtbl = &IDirectXFileData_Vtbl;
1208     object->ref = 1;
1209
1210     *ppObj = object;
1211
1212     return S_OK;
1213 }
1214
1215 /*** IUnknown methods ***/
1216 static HRESULT WINAPI IDirectXFileDataImpl_QueryInterface(IDirectXFileData* iface, REFIID riid, void** ppvObject)
1217 {
1218   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1219
1220   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1221
1222   if (IsEqualGUID(riid, &IID_IUnknown)
1223       || IsEqualGUID(riid, &IID_IDirectXFileObject)
1224       || IsEqualGUID(riid, &IID_IDirectXFileData))
1225   {
1226     IClassFactory_AddRef(iface);
1227     *ppvObject = This;
1228     return S_OK;
1229   }
1230
1231   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1232   return E_NOINTERFACE;
1233 }
1234
1235 static ULONG WINAPI IDirectXFileDataImpl_AddRef(IDirectXFileData* iface)
1236 {
1237   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1238   ULONG ref = InterlockedIncrement(&This->ref);
1239
1240   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1241
1242   return ref;
1243 }
1244
1245 static ULONG WINAPI IDirectXFileDataImpl_Release(IDirectXFileData* iface)
1246 {
1247   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1248   ULONG ref = InterlockedDecrement(&This->ref);
1249
1250   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1251
1252   if (!ref)
1253     HeapFree(GetProcessHeap(), 0, This);
1254
1255   return ref;
1256 }
1257
1258 /*** IDirectXFileObject methods ***/
1259 static HRESULT WINAPI IDirectXFileDataImpl_GetName(IDirectXFileData* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1260
1261 {
1262   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1263
1264   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1265
1266   return DXFILEERR_BADVALUE;
1267 }
1268
1269 static HRESULT WINAPI IDirectXFileDataImpl_GetId(IDirectXFileData* iface, LPGUID pGuid)
1270 {
1271   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1272
1273   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1274
1275   return DXFILEERR_BADVALUE;
1276 }
1277
1278 /*** IDirectXFileData methods ***/
1279 static HRESULT WINAPI IDirectXFileDataImpl_GetData(IDirectXFileData* iface, LPCSTR szMember, DWORD* pcbSize, void** ppvData)
1280 {
1281   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1282
1283   FIXME("(%p/%p)->(%s,%p,%p) stub!\n", This, iface, szMember, pcbSize, ppvData);
1284
1285   return DXFILEERR_BADVALUE;
1286 }
1287
1288 static HRESULT WINAPI IDirectXFileDataImpl_GetType(IDirectXFileData* iface, const GUID** pguid)
1289 {
1290   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1291
1292   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pguid);
1293
1294   return DXFILEERR_BADVALUE;
1295 }
1296
1297 static HRESULT WINAPI IDirectXFileDataImpl_GetNextObject(IDirectXFileData* iface, LPDIRECTXFILEOBJECT* ppChildObj)
1298 {
1299   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1300
1301   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppChildObj);
1302
1303   return DXFILEERR_BADVALUE;
1304 }
1305
1306 static HRESULT WINAPI IDirectXFileDataImpl_AddDataObject(IDirectXFileData* iface, LPDIRECTXFILEDATA pDataObj)
1307 {
1308   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1309
1310   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pDataObj);
1311
1312   return DXFILEERR_BADVALUE;
1313 }
1314
1315 static HRESULT WINAPI IDirectXFileDataImpl_AddDataReference(IDirectXFileData* iface, LPCSTR szRef, const GUID* pguidRef)
1316 {
1317   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1318
1319   FIXME("(%p/%p)->(%s,%p) stub!\n", This, iface, szRef, pguidRef);
1320
1321   return DXFILEERR_BADVALUE;
1322 }
1323
1324 static HRESULT WINAPI IDirectXFileDataImpl_AddBinaryObject(IDirectXFileData* iface, LPCSTR szName, const GUID* pguid, LPCSTR szMimeType, LPVOID pvData, DWORD cbSize)
1325 {
1326   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1327
1328   FIXME("(%p/%p)->(%s,%p,%s,%p,%d) stub!\n", This, iface, szName, pguid, szMimeType, pvData, cbSize);
1329
1330   return DXFILEERR_BADVALUE;
1331 }
1332
1333 static const IDirectXFileDataVtbl IDirectXFileData_Vtbl =
1334 {
1335     IDirectXFileDataImpl_QueryInterface,
1336     IDirectXFileDataImpl_AddRef,
1337     IDirectXFileDataImpl_Release,
1338     IDirectXFileDataImpl_GetName,
1339     IDirectXFileDataImpl_GetId,
1340     IDirectXFileDataImpl_GetData,
1341     IDirectXFileDataImpl_GetType,
1342     IDirectXFileDataImpl_GetNextObject,
1343     IDirectXFileDataImpl_AddDataObject,
1344     IDirectXFileDataImpl_AddDataReference,
1345     IDirectXFileDataImpl_AddBinaryObject
1346 };
1347
1348 HRESULT IDirectXFileDataReferenceImpl_Create(IDirectXFileDataReferenceImpl** ppObj)
1349 {
1350     IDirectXFileDataReferenceImpl* object;
1351
1352     TRACE("(%p)\n", ppObj);
1353
1354     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataReferenceImpl));
1355
1356     object->lpVtbl.lpVtbl = &IDirectXFileDataReference_Vtbl;
1357     object->ref = 1;
1358
1359     *ppObj = object;
1360
1361     return S_OK;
1362 }
1363
1364 /*** IUnknown methods ***/
1365 static HRESULT WINAPI IDirectXFileDataReferenceImpl_QueryInterface(IDirectXFileDataReference* iface, REFIID riid, void** ppvObject)
1366 {
1367   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1368
1369   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1370
1371   if (IsEqualGUID(riid, &IID_IUnknown)
1372       || IsEqualGUID(riid, &IID_IDirectXFileObject)
1373       || IsEqualGUID(riid, &IID_IDirectXFileDataReference))
1374   {
1375     IClassFactory_AddRef(iface);
1376     *ppvObject = This;
1377     return S_OK;
1378   }
1379
1380   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1381   return E_NOINTERFACE;
1382 }
1383
1384 static ULONG WINAPI IDirectXFileDataReferenceImpl_AddRef(IDirectXFileDataReference* iface)
1385 {
1386   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1387   ULONG ref = InterlockedIncrement(&This->ref);
1388
1389   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1390
1391   return ref;
1392 }
1393
1394 static ULONG WINAPI IDirectXFileDataReferenceImpl_Release(IDirectXFileDataReference* iface)
1395 {
1396   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1397   ULONG ref = InterlockedDecrement(&This->ref);
1398
1399   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1400
1401   if (!ref)
1402     HeapFree(GetProcessHeap(), 0, This);
1403
1404   return ref;
1405 }
1406
1407 /*** IDirectXFileObject methods ***/
1408 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetName(IDirectXFileDataReference* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1409 {
1410   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1411
1412   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1413
1414   return DXFILEERR_BADVALUE;
1415 }
1416
1417 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetId(IDirectXFileDataReference* iface, LPGUID pGuid)
1418 {
1419   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1420
1421   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1422
1423   return DXFILEERR_BADVALUE;
1424 }
1425
1426 /*** IDirectXFileDataReference ***/
1427 static HRESULT WINAPI IDirectXFileDataReferenceImpl_Resolve(IDirectXFileDataReference* iface, LPDIRECTXFILEDATA* ppDataObj)
1428 {
1429   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1430
1431   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppDataObj);
1432
1433   return DXFILEERR_BADVALUE;
1434 }
1435
1436 static const IDirectXFileDataReferenceVtbl IDirectXFileDataReference_Vtbl =
1437 {
1438     IDirectXFileDataReferenceImpl_QueryInterface,
1439     IDirectXFileDataReferenceImpl_AddRef,
1440     IDirectXFileDataReferenceImpl_Release,
1441     IDirectXFileDataReferenceImpl_GetName,
1442     IDirectXFileDataReferenceImpl_GetId,
1443     IDirectXFileDataReferenceImpl_Resolve
1444 };
1445
1446 HRESULT IDirectXFileEnumObjectImpl_Create(IDirectXFileEnumObjectImpl** ppObj)
1447 {
1448     IDirectXFileEnumObjectImpl* object;
1449
1450     TRACE("(%p)\n", ppObj);
1451
1452     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileEnumObjectImpl));
1453
1454     object->lpVtbl.lpVtbl = &IDirectXFileEnumObject_Vtbl;
1455     object->ref = 1;
1456
1457     *ppObj = object;
1458
1459     return S_OK;
1460 }
1461
1462 /*** IUnknown methods ***/
1463 static HRESULT WINAPI IDirectXFileEnumObjectImpl_QueryInterface(IDirectXFileEnumObject* iface, REFIID riid, void** ppvObject)
1464 {
1465   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1466
1467   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1468
1469   if (IsEqualGUID(riid, &IID_IUnknown)
1470       || IsEqualGUID(riid, &IID_IDirectXFileEnumObject))
1471   {
1472     IClassFactory_AddRef(iface);
1473     *ppvObject = This;
1474     return S_OK;
1475   }
1476
1477   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1478   return E_NOINTERFACE;
1479 }
1480
1481 static ULONG WINAPI IDirectXFileEnumObjectImpl_AddRef(IDirectXFileEnumObject* iface)
1482 {
1483   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1484   ULONG ref = InterlockedIncrement(&This->ref);
1485
1486   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1487
1488   return ref;
1489 }
1490
1491 static ULONG WINAPI IDirectXFileEnumObjectImpl_Release(IDirectXFileEnumObject* iface)
1492 {
1493   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1494   ULONG ref = InterlockedDecrement(&This->ref);
1495
1496   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1497
1498   if (!ref)
1499     HeapFree(GetProcessHeap(), 0, This);
1500
1501   return ref;
1502 }
1503
1504 /*** IDirectXFileEnumObject methods ***/
1505 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetNextDataObject(IDirectXFileEnumObject* iface, LPDIRECTXFILEDATA* ppDataObj)
1506 {
1507   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1508   IDirectXFileDataImpl* object;
1509   HRESULT hr;
1510
1511   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppDataObj);
1512
1513   hr = IDirectXFileDataImpl_Create(&object);
1514   if (!SUCCEEDED(hr))
1515     return hr;
1516
1517   *ppDataObj = (LPDIRECTXFILEDATA)object;
1518
1519   return DXFILE_OK;
1520 }
1521
1522 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectById(IDirectXFileEnumObject* iface, REFGUID rguid, LPDIRECTXFILEDATA* ppDataObj)
1523 {
1524   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1525
1526   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, rguid, ppDataObj);
1527
1528   return DXFILEERR_BADVALUE;
1529 }
1530
1531 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectByName(IDirectXFileEnumObject* iface, LPCSTR szName, LPDIRECTXFILEDATA* ppDataObj)
1532 {
1533   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1534
1535   FIXME("(%p/%p)->(%s,%p) stub!\n", This, iface, szName, ppDataObj);
1536
1537   return DXFILEERR_BADVALUE;
1538 }
1539
1540 static const IDirectXFileEnumObjectVtbl IDirectXFileEnumObject_Vtbl =
1541 {
1542     IDirectXFileEnumObjectImpl_QueryInterface,
1543     IDirectXFileEnumObjectImpl_AddRef,
1544     IDirectXFileEnumObjectImpl_Release,
1545     IDirectXFileEnumObjectImpl_GetNextDataObject,
1546     IDirectXFileEnumObjectImpl_GetDataObjectById,
1547     IDirectXFileEnumObjectImpl_GetDataObjectByName
1548 };
1549
1550 HRESULT IDirectXFileObjectImpl_Create(IDirectXFileObjectImpl** ppObj)
1551 {
1552     IDirectXFileObjectImpl* object;
1553
1554     TRACE("(%p)\n", ppObj);
1555
1556     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileObjectImpl));
1557
1558     object->lpVtbl.lpVtbl = &IDirectXFileObject_Vtbl;
1559     object->ref = 1;
1560
1561     *ppObj = object;
1562
1563     return S_OK;
1564 }
1565
1566 /*** IUnknown methods ***/
1567 static HRESULT WINAPI IDirectXFileObjectImpl_QueryInterface(IDirectXFileObject* iface, REFIID riid, void** ppvObject)
1568 {
1569   IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
1570
1571   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1572
1573   if (IsEqualGUID(riid, &IID_IUnknown)
1574       || IsEqualGUID(riid, &IID_IDirectXFileObject))
1575   {
1576     IClassFactory_AddRef(iface);
1577     *ppvObject = This;
1578     return S_OK;
1579   }
1580
1581   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1582   return E_NOINTERFACE;
1583 }
1584
1585 static ULONG WINAPI IDirectXFileObjectImpl_AddRef(IDirectXFileObject* iface)
1586 {
1587   IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
1588   ULONG ref = InterlockedIncrement(&This->ref);
1589
1590   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1591
1592   return ref;
1593 }
1594
1595 static ULONG WINAPI IDirectXFileObjectImpl_Release(IDirectXFileObject* iface)
1596 {
1597   IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
1598   ULONG ref = InterlockedDecrement(&This->ref);
1599
1600   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1601
1602   if (!ref)
1603     HeapFree(GetProcessHeap(), 0, This);
1604
1605   return ref;
1606 }
1607
1608 /*** IDirectXFileObject methods ***/
1609 static HRESULT WINAPI IDirectXFileObjectImpl_GetName(IDirectXFileObject* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1610 {
1611   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1612
1613   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1614
1615   return DXFILEERR_BADVALUE;
1616 }
1617
1618 static HRESULT WINAPI IDirectXFileObjectImpl_GetId(IDirectXFileObject* iface, LPGUID pGuid)
1619 {
1620   IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
1621
1622   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1623
1624   return DXFILEERR_BADVALUE;
1625 }
1626
1627 static const IDirectXFileObjectVtbl IDirectXFileObject_Vtbl =
1628 {
1629     IDirectXFileObjectImpl_QueryInterface,
1630     IDirectXFileObjectImpl_AddRef,
1631     IDirectXFileObjectImpl_Release,
1632     IDirectXFileObjectImpl_GetName,
1633     IDirectXFileObjectImpl_GetId
1634 };
1635
1636 HRESULT IDirectXFileSaveObjectImpl_Create(IDirectXFileSaveObjectImpl** ppObj)
1637 {
1638     IDirectXFileSaveObjectImpl* object;
1639
1640     TRACE("(%p)\n", ppObj);
1641
1642     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileSaveObjectImpl));
1643
1644     object->lpVtbl.lpVtbl = &IDirectXFileSaveObject_Vtbl;
1645     object->ref = 1;
1646
1647     *ppObj = object;
1648
1649     return S_OK;
1650 }
1651
1652 /*** IUnknown methods ***/
1653 static HRESULT WINAPI IDirectXFileSaveObjectImpl_QueryInterface(IDirectXFileSaveObject* iface, REFIID riid, void** ppvObject)
1654 {
1655   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1656
1657   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1658
1659   if (IsEqualGUID(riid, &IID_IUnknown)
1660       || IsEqualGUID(riid, &IID_IDirectXFileSaveObject))
1661   {
1662     IClassFactory_AddRef(iface);
1663     *ppvObject = This;
1664     return S_OK;
1665   }
1666
1667   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1668   return E_NOINTERFACE;
1669 }
1670
1671 static ULONG WINAPI IDirectXFileSaveObjectImpl_AddRef(IDirectXFileSaveObject* iface)
1672 {
1673   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1674   ULONG ref = InterlockedIncrement(&This->ref);
1675
1676   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1677
1678   return ref;
1679 }
1680
1681 static ULONG WINAPI IDirectXFileSaveObjectImpl_Release(IDirectXFileSaveObject* iface)
1682 {
1683   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1684   ULONG ref = InterlockedDecrement(&This->ref);
1685
1686   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1687
1688   if (!ref)
1689     HeapFree(GetProcessHeap(), 0, This);
1690
1691   return ref;
1692 }
1693
1694 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveTemplates(IDirectXFileSaveObject* iface, DWORD cTemplates, const GUID** ppguidTemplates)
1695 {
1696   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1697
1698   FIXME("(%p/%p)->(%d,%p) stub!\n", This, iface, cTemplates, ppguidTemplates);
1699
1700   return DXFILEERR_BADVALUE;
1701 }
1702
1703 static HRESULT WINAPI IDirectXFileSaveObjectImpl_CreateDataObject(IDirectXFileSaveObject* iface, REFGUID rguidTemplate, LPCSTR szName, const GUID* pguid, DWORD cbSize, LPVOID pvData, LPDIRECTXFILEDATA* ppDataObj)
1704 {
1705   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1706
1707   FIXME("(%p/%p)->(%p,%s,%p,%d,%p,%p) stub!\n", This, iface, rguidTemplate, szName, pguid, cbSize, pvData, ppDataObj);
1708
1709   return DXFILEERR_BADVALUE;
1710 }
1711
1712 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveData(IDirectXFileSaveObject* iface, LPDIRECTXFILEDATA ppDataObj)
1713 {
1714   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1715
1716   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppDataObj);
1717
1718   return DXFILEERR_BADVALUE;
1719 }
1720
1721 static const IDirectXFileSaveObjectVtbl IDirectXFileSaveObject_Vtbl =
1722 {
1723     IDirectXFileSaveObjectImpl_QueryInterface,
1724     IDirectXFileSaveObjectImpl_AddRef,
1725     IDirectXFileSaveObjectImpl_Release,
1726     IDirectXFileSaveObjectImpl_SaveTemplates,
1727     IDirectXFileSaveObjectImpl_CreateDataObject,
1728     IDirectXFileSaveObjectImpl_SaveData
1729 };