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, "STRING"))
 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')) || ((c >= '0') && (c <= '9'))))
 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 "STRING";
 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 a nonexistent 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 nonexistent 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 && is_space(*buf->buffer))
 931     {
 932       buf->buffer++;
 933       buf->rem_bytes--;
 934     }
 935   }
 936
 937   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));
 938   buf->pdxf->nb_xtemplates++;
 939
 940   return TRUE;
 941 }
 942
 943 static HRESULT WINAPI IDirectXFileImpl_RegisterTemplates(IDirectXFile* iface, LPVOID pvData, DWORD cbSize)
 944 {
 945   IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
 946   DWORD token_header;
 947   parse_buffer buf;
 948
 949   buf.buffer = (LPBYTE)pvData;
 950   buf.rem_bytes = cbSize;
 951   buf.txt = FALSE;
 952   buf.pdxf = This;
 953
 954   FIXME("(%p/%p)->(%p,%d) partial stub!\n", This, iface, pvData, cbSize);
 955
 956   if (!pvData)
 957     return DXFILEERR_BADVALUE;
 958
 959   if (cbSize < 16)
 960     return DXFILEERR_BADFILETYPE;
 961
 962   if (TRACE_ON(d3dxof))
 963   {
 964     char string[17];
 965     memcpy(string, pvData, 16);
 966     string[16] = 0;
 967     TRACE("header = '%s'\n", string);
 968   }
 969
 970   read_bytes(&buf, &token_header, 4);
 971
 972   if (token_header != XOFFILE_FORMAT_MAGIC)
 973     return DXFILEERR_BADFILETYPE;
 974
 975   read_bytes(&buf, &token_header, 4);
 976
 977   if (token_header != XOFFILE_FORMAT_VERSION)
 978     return DXFILEERR_BADFILEVERSION;
 979
 980   read_bytes(&buf, &token_header, 4);
 981
 982   if ((token_header != XOFFILE_FORMAT_BINARY) && (token_header != XOFFILE_FORMAT_TEXT) && (token_header != XOFFILE_FORMAT_COMPRESSED))
 983     return DXFILEERR_BADFILETYPE;
 984
 985   if (token_header == XOFFILE_FORMAT_TEXT)
 986   {
 987     buf.txt = TRUE;
 988   }
 989
 990   if (token_header == XOFFILE_FORMAT_COMPRESSED)
 991   {
 992     FIXME("Compressed formats not supported yet\n");
 993     return DXFILEERR_BADVALUE;
 994   }
 995
 996   read_bytes(&buf, &token_header, 4);
 997
 998   if ((token_header != XOFFILE_FORMAT_FLOAT_BITS_32) && (token_header != XOFFILE_FORMAT_FLOAT_BITS_64))
 999     return DXFILEERR_BADFILEFLOATSIZE;
1000
1001   TRACE("Header is correct\n");
1002
1003   while (buf.rem_bytes)
1004   {
1005     if (!parse_template(&buf))
1006     {
1007       TRACE("Template is not correct\n");
1008       return DXFILEERR_BADVALUE;
1009     }
1010     else
1011     {
1012       TRACE("Template successfully parsed:\n");
1013       if (TRACE_ON(d3dxof))
1014       {
1015         int i,j,k;
1016         GUID* clsid;
1017
1018         i = This->nb_xtemplates - 1;
1019         clsid = &This->xtemplates[i].class_id;
1020
1021         DPRINTF("template %s\n", This->xtemplates[i].name);
1022         DPRINTF("{\n");
1023         DPRINTF(CLSIDFMT "\n", clsid->Data1, clsid->Data2, clsid->Data3, clsid->Data4[0],
1024           clsid->Data4[1], clsid->Data4[2], clsid->Data4[3], clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7]);
1025         for (j = 0; j < This->xtemplates[i].nb_members; j++)
1026         {
1027           if (This->xtemplates[i].members[j].nb_dims)
1028             DPRINTF("array ");
1029           if (This->xtemplates[i].members[j].type == TOKEN_NAME)
1030             DPRINTF("%s ", This->xtemplates[This->xtemplates[i].members[j].idx_template].name);
1031           else
1032             DPRINTF("%s ", get_primitive_string(This->xtemplates[i].members[j].type));
1033           DPRINTF("%s", This->xtemplates[i].members[j].name);
1034           for (k = 0; k < This->xtemplates[i].members[j].nb_dims; k++)
1035           {
1036             if (This->xtemplates[i].members[j].dim_fixed[k])
1037               DPRINTF("[%d]", This->xtemplates[i].members[j].dim_value[k]);
1038             else
1039               DPRINTF("[%s]", This->xtemplates[i].members[This->xtemplates[i].members[j].dim_value[k]].name);
1040           }
1041           DPRINTF(";\n");
1042         }
1043         if (This->xtemplates[i].open)
1044           DPRINTF("[...]\n");
1045         else if (This->xtemplates[i].nb_childs)
1046         {
1047           DPRINTF("[%s", This->xtemplates[i].childs[0]);
1048           for (j = 1; j < This->xtemplates[i].nb_childs; j++)
1049             DPRINTF(",%s", This->xtemplates[i].childs[j]);
1050           DPRINTF("]\n");
1051         }
1052         DPRINTF("}\n");
1053       }
1054     }
1055   }
1056
1057   if (TRACE_ON(d3dxof))
1058   {
1059     int i;
1060     TRACE("Registered templates (%d):\n", This->nb_xtemplates);
1061     for (i = 0; i < This->nb_xtemplates; i++)
1062       DPRINTF("%s - %s\n", This->xtemplates[i].name, debugstr_guid(&This->xtemplates[i].class_id));
1063   }
1064
1065   return DXFILE_OK;
1066 }
1067
1068 static const IDirectXFileVtbl IDirectXFile_Vtbl =
1069 {
1070   IDirectXFileImpl_QueryInterface,
1071   IDirectXFileImpl_AddRef,
1072   IDirectXFileImpl_Release,
1073   IDirectXFileImpl_CreateEnumObject,
1074   IDirectXFileImpl_CreateSaveObject,
1075   IDirectXFileImpl_RegisterTemplates
1076 };
1077
1078 HRESULT IDirectXFileBinaryImpl_Create(IDirectXFileBinaryImpl** ppObj)
1079 {
1080     IDirectXFileBinaryImpl* object;
1081
1082     TRACE("(%p)\n", ppObj);
1083
1084     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileBinaryImpl));
1085
1086     object->lpVtbl.lpVtbl = &IDirectXFileBinary_Vtbl;
1087     object->ref = 1;
1088
1089     *ppObj = object;
1090
1091     return DXFILE_OK;
1092 }
1093
1094 /*** IUnknown methods ***/
1095 static HRESULT WINAPI IDirectXFileBinaryImpl_QueryInterface(IDirectXFileBinary* iface, REFIID riid, void** ppvObject)
1096 {
1097   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1098
1099   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1100
1101   if (IsEqualGUID(riid, &IID_IUnknown)
1102       || IsEqualGUID(riid, &IID_IDirectXFileObject)
1103       || IsEqualGUID(riid, &IID_IDirectXFileBinary))
1104   {
1105     IClassFactory_AddRef(iface);
1106     *ppvObject = This;
1107     return S_OK;
1108   }
1109
1110   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1111   return E_NOINTERFACE;
1112 }
1113
1114 static ULONG WINAPI IDirectXFileBinaryImpl_AddRef(IDirectXFileBinary* iface)
1115 {
1116   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1117   ULONG ref = InterlockedIncrement(&This->ref);
1118
1119   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1120
1121   return ref;
1122 }
1123
1124 static ULONG WINAPI IDirectXFileBinaryImpl_Release(IDirectXFileBinary* iface)
1125 {
1126   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1127   ULONG ref = InterlockedDecrement(&This->ref);
1128
1129   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1130
1131   if (!ref)
1132     HeapFree(GetProcessHeap(), 0, This);
1133
1134   return ref;
1135 }
1136
1137 /*** IDirectXFileObject methods ***/
1138 static HRESULT WINAPI IDirectXFileBinaryImpl_GetName(IDirectXFileBinary* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1139
1140 {
1141   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1142
1143   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1144
1145   return DXFILEERR_BADVALUE;
1146 }
1147
1148 static HRESULT WINAPI IDirectXFileBinaryImpl_GetId(IDirectXFileBinary* iface, LPGUID pGuid)
1149 {
1150   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1151
1152   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1153
1154   return DXFILEERR_BADVALUE;
1155 }
1156
1157 /*** IDirectXFileBinary methods ***/
1158 static HRESULT WINAPI IDirectXFileBinaryImpl_GetSize(IDirectXFileBinary* iface, DWORD* pcbSize)
1159 {
1160   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1161
1162   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pcbSize);
1163
1164   return DXFILEERR_BADVALUE;
1165 }
1166
1167 static HRESULT WINAPI IDirectXFileBinaryImpl_GetMimeType(IDirectXFileBinary* iface, LPCSTR* pszMimeType)
1168 {
1169   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1170
1171   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pszMimeType);
1172
1173   return DXFILEERR_BADVALUE;
1174 }
1175
1176 static HRESULT WINAPI IDirectXFileBinaryImpl_Read(IDirectXFileBinary* iface, LPVOID pvData, DWORD cbSize, LPDWORD pcbRead)
1177 {
1178   IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1179
1180   FIXME("(%p/%p)->(%p, %d, %p) stub!\n", This, iface, pvData, cbSize, pcbRead);
1181
1182   return DXFILEERR_BADVALUE;
1183 }
1184
1185 static const IDirectXFileBinaryVtbl IDirectXFileBinary_Vtbl =
1186 {
1187     IDirectXFileBinaryImpl_QueryInterface,
1188     IDirectXFileBinaryImpl_AddRef,
1189     IDirectXFileBinaryImpl_Release,
1190     IDirectXFileBinaryImpl_GetName,
1191     IDirectXFileBinaryImpl_GetId,
1192     IDirectXFileBinaryImpl_GetSize,
1193     IDirectXFileBinaryImpl_GetMimeType,
1194     IDirectXFileBinaryImpl_Read
1195 };
1196
1197 HRESULT IDirectXFileDataImpl_Create(IDirectXFileDataImpl** ppObj)
1198 {
1199     IDirectXFileDataImpl* object;
1200
1201     TRACE("(%p)\n", ppObj);
1202
1203     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataImpl));
1204
1205     object->lpVtbl.lpVtbl = &IDirectXFileData_Vtbl;
1206     object->ref = 1;
1207
1208     *ppObj = object;
1209
1210     return S_OK;
1211 }
1212
1213 /*** IUnknown methods ***/
1214 static HRESULT WINAPI IDirectXFileDataImpl_QueryInterface(IDirectXFileData* iface, REFIID riid, void** ppvObject)
1215 {
1216   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1217
1218   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1219
1220   if (IsEqualGUID(riid, &IID_IUnknown)
1221       || IsEqualGUID(riid, &IID_IDirectXFileObject)
1222       || IsEqualGUID(riid, &IID_IDirectXFileData))
1223   {
1224     IClassFactory_AddRef(iface);
1225     *ppvObject = This;
1226     return S_OK;
1227   }
1228
1229   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1230   return E_NOINTERFACE;
1231 }
1232
1233 static ULONG WINAPI IDirectXFileDataImpl_AddRef(IDirectXFileData* iface)
1234 {
1235   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1236   ULONG ref = InterlockedIncrement(&This->ref);
1237
1238   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1239
1240   return ref;
1241 }
1242
1243 static ULONG WINAPI IDirectXFileDataImpl_Release(IDirectXFileData* iface)
1244 {
1245   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1246   ULONG ref = InterlockedDecrement(&This->ref);
1247
1248   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1249
1250   if (!ref)
1251     HeapFree(GetProcessHeap(), 0, This);
1252
1253   return ref;
1254 }
1255
1256 /*** IDirectXFileObject methods ***/
1257 static HRESULT WINAPI IDirectXFileDataImpl_GetName(IDirectXFileData* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1258
1259 {
1260   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1261
1262   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1263
1264   return DXFILEERR_BADVALUE;
1265 }
1266
1267 static HRESULT WINAPI IDirectXFileDataImpl_GetId(IDirectXFileData* iface, LPGUID pGuid)
1268 {
1269   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1270
1271   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1272
1273   return DXFILEERR_BADVALUE;
1274 }
1275
1276 /*** IDirectXFileData methods ***/
1277 static HRESULT WINAPI IDirectXFileDataImpl_GetData(IDirectXFileData* iface, LPCSTR szMember, DWORD* pcbSize, void** ppvData)
1278 {
1279   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1280
1281   FIXME("(%p/%p)->(%s,%p,%p) stub!\n", This, iface, szMember, pcbSize, ppvData);
1282
1283   return DXFILEERR_BADVALUE;
1284 }
1285
1286 static HRESULT WINAPI IDirectXFileDataImpl_GetType(IDirectXFileData* iface, const GUID** pguid)
1287 {
1288   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1289
1290   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pguid);
1291
1292   return DXFILEERR_BADVALUE;
1293 }
1294
1295 static HRESULT WINAPI IDirectXFileDataImpl_GetNextObject(IDirectXFileData* iface, LPDIRECTXFILEOBJECT* ppChildObj)
1296 {
1297   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1298
1299   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppChildObj);
1300
1301   return DXFILEERR_BADVALUE;
1302 }
1303
1304 static HRESULT WINAPI IDirectXFileDataImpl_AddDataObject(IDirectXFileData* iface, LPDIRECTXFILEDATA pDataObj)
1305 {
1306   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1307
1308   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pDataObj);
1309
1310   return DXFILEERR_BADVALUE;
1311 }
1312
1313 static HRESULT WINAPI IDirectXFileDataImpl_AddDataReference(IDirectXFileData* iface, LPCSTR szRef, const GUID* pguidRef)
1314 {
1315   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1316
1317   FIXME("(%p/%p)->(%s,%p) stub!\n", This, iface, szRef, pguidRef);
1318
1319   return DXFILEERR_BADVALUE;
1320 }
1321
1322 static HRESULT WINAPI IDirectXFileDataImpl_AddBinaryObject(IDirectXFileData* iface, LPCSTR szName, const GUID* pguid, LPCSTR szMimeType, LPVOID pvData, DWORD cbSize)
1323 {
1324   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1325
1326   FIXME("(%p/%p)->(%s,%p,%s,%p,%d) stub!\n", This, iface, szName, pguid, szMimeType, pvData, cbSize);
1327
1328   return DXFILEERR_BADVALUE;
1329 }
1330
1331 static const IDirectXFileDataVtbl IDirectXFileData_Vtbl =
1332 {
1333     IDirectXFileDataImpl_QueryInterface,
1334     IDirectXFileDataImpl_AddRef,
1335     IDirectXFileDataImpl_Release,
1336     IDirectXFileDataImpl_GetName,
1337     IDirectXFileDataImpl_GetId,
1338     IDirectXFileDataImpl_GetData,
1339     IDirectXFileDataImpl_GetType,
1340     IDirectXFileDataImpl_GetNextObject,
1341     IDirectXFileDataImpl_AddDataObject,
1342     IDirectXFileDataImpl_AddDataReference,
1343     IDirectXFileDataImpl_AddBinaryObject
1344 };
1345
1346 HRESULT IDirectXFileDataReferenceImpl_Create(IDirectXFileDataReferenceImpl** ppObj)
1347 {
1348     IDirectXFileDataReferenceImpl* object;
1349
1350     TRACE("(%p)\n", ppObj);
1351
1352     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataReferenceImpl));
1353
1354     object->lpVtbl.lpVtbl = &IDirectXFileDataReference_Vtbl;
1355     object->ref = 1;
1356
1357     *ppObj = object;
1358
1359     return S_OK;
1360 }
1361
1362 /*** IUnknown methods ***/
1363 static HRESULT WINAPI IDirectXFileDataReferenceImpl_QueryInterface(IDirectXFileDataReference* iface, REFIID riid, void** ppvObject)
1364 {
1365   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1366
1367   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1368
1369   if (IsEqualGUID(riid, &IID_IUnknown)
1370       || IsEqualGUID(riid, &IID_IDirectXFileObject)
1371       || IsEqualGUID(riid, &IID_IDirectXFileDataReference))
1372   {
1373     IClassFactory_AddRef(iface);
1374     *ppvObject = This;
1375     return S_OK;
1376   }
1377
1378   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1379   return E_NOINTERFACE;
1380 }
1381
1382 static ULONG WINAPI IDirectXFileDataReferenceImpl_AddRef(IDirectXFileDataReference* iface)
1383 {
1384   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1385   ULONG ref = InterlockedIncrement(&This->ref);
1386
1387   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1388
1389   return ref;
1390 }
1391
1392 static ULONG WINAPI IDirectXFileDataReferenceImpl_Release(IDirectXFileDataReference* iface)
1393 {
1394   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1395   ULONG ref = InterlockedDecrement(&This->ref);
1396
1397   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1398
1399   if (!ref)
1400     HeapFree(GetProcessHeap(), 0, This);
1401
1402   return ref;
1403 }
1404
1405 /*** IDirectXFileObject methods ***/
1406 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetName(IDirectXFileDataReference* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1407 {
1408   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1409
1410   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1411
1412   return DXFILEERR_BADVALUE;
1413 }
1414
1415 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetId(IDirectXFileDataReference* iface, LPGUID pGuid)
1416 {
1417   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1418
1419   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1420
1421   return DXFILEERR_BADVALUE;
1422 }
1423
1424 /*** IDirectXFileDataReference ***/
1425 static HRESULT WINAPI IDirectXFileDataReferenceImpl_Resolve(IDirectXFileDataReference* iface, LPDIRECTXFILEDATA* ppDataObj)
1426 {
1427   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1428
1429   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppDataObj);
1430
1431   return DXFILEERR_BADVALUE;
1432 }
1433
1434 static const IDirectXFileDataReferenceVtbl IDirectXFileDataReference_Vtbl =
1435 {
1436     IDirectXFileDataReferenceImpl_QueryInterface,
1437     IDirectXFileDataReferenceImpl_AddRef,
1438     IDirectXFileDataReferenceImpl_Release,
1439     IDirectXFileDataReferenceImpl_GetName,
1440     IDirectXFileDataReferenceImpl_GetId,
1441     IDirectXFileDataReferenceImpl_Resolve
1442 };
1443
1444 HRESULT IDirectXFileEnumObjectImpl_Create(IDirectXFileEnumObjectImpl** ppObj)
1445 {
1446     IDirectXFileEnumObjectImpl* object;
1447
1448     TRACE("(%p)\n", ppObj);
1449
1450     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileEnumObjectImpl));
1451
1452     object->lpVtbl.lpVtbl = &IDirectXFileEnumObject_Vtbl;
1453     object->ref = 1;
1454
1455     *ppObj = object;
1456
1457     return S_OK;
1458 }
1459
1460 /*** IUnknown methods ***/
1461 static HRESULT WINAPI IDirectXFileEnumObjectImpl_QueryInterface(IDirectXFileEnumObject* iface, REFIID riid, void** ppvObject)
1462 {
1463   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1464
1465   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1466
1467   if (IsEqualGUID(riid, &IID_IUnknown)
1468       || IsEqualGUID(riid, &IID_IDirectXFileEnumObject))
1469   {
1470     IClassFactory_AddRef(iface);
1471     *ppvObject = This;
1472     return S_OK;
1473   }
1474
1475   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1476   return E_NOINTERFACE;
1477 }
1478
1479 static ULONG WINAPI IDirectXFileEnumObjectImpl_AddRef(IDirectXFileEnumObject* iface)
1480 {
1481   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1482   ULONG ref = InterlockedIncrement(&This->ref);
1483
1484   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1485
1486   return ref;
1487 }
1488
1489 static ULONG WINAPI IDirectXFileEnumObjectImpl_Release(IDirectXFileEnumObject* iface)
1490 {
1491   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1492   ULONG ref = InterlockedDecrement(&This->ref);
1493
1494   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1495
1496   if (!ref)
1497     HeapFree(GetProcessHeap(), 0, This);
1498
1499   return ref;
1500 }
1501
1502 /*** IDirectXFileEnumObject methods ***/
1503 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetNextDataObject(IDirectXFileEnumObject* iface, LPDIRECTXFILEDATA* ppDataObj)
1504 {
1505   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1506   IDirectXFileDataImpl* object;
1507   HRESULT hr;
1508
1509   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppDataObj);
1510
1511   hr = IDirectXFileDataImpl_Create(&object);
1512   if (!SUCCEEDED(hr))
1513     return hr;
1514
1515   *ppDataObj = (LPDIRECTXFILEDATA)object;
1516
1517   return DXFILE_OK;
1518 }
1519
1520 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectById(IDirectXFileEnumObject* iface, REFGUID rguid, LPDIRECTXFILEDATA* ppDataObj)
1521 {
1522   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1523
1524   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, rguid, ppDataObj);
1525
1526   return DXFILEERR_BADVALUE;
1527 }
1528
1529 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectByName(IDirectXFileEnumObject* iface, LPCSTR szName, LPDIRECTXFILEDATA* ppDataObj)
1530 {
1531   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1532
1533   FIXME("(%p/%p)->(%s,%p) stub!\n", This, iface, szName, ppDataObj);
1534
1535   return DXFILEERR_BADVALUE;
1536 }
1537
1538 static const IDirectXFileEnumObjectVtbl IDirectXFileEnumObject_Vtbl =
1539 {
1540     IDirectXFileEnumObjectImpl_QueryInterface,
1541     IDirectXFileEnumObjectImpl_AddRef,
1542     IDirectXFileEnumObjectImpl_Release,
1543     IDirectXFileEnumObjectImpl_GetNextDataObject,
1544     IDirectXFileEnumObjectImpl_GetDataObjectById,
1545     IDirectXFileEnumObjectImpl_GetDataObjectByName
1546 };
1547
1548 HRESULT IDirectXFileObjectImpl_Create(IDirectXFileObjectImpl** ppObj)
1549 {
1550     IDirectXFileObjectImpl* object;
1551
1552     TRACE("(%p)\n", ppObj);
1553
1554     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileObjectImpl));
1555
1556     object->lpVtbl.lpVtbl = &IDirectXFileObject_Vtbl;
1557     object->ref = 1;
1558
1559     *ppObj = object;
1560
1561     return S_OK;
1562 }
1563
1564 /*** IUnknown methods ***/
1565 static HRESULT WINAPI IDirectXFileObjectImpl_QueryInterface(IDirectXFileObject* iface, REFIID riid, void** ppvObject)
1566 {
1567   IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
1568
1569   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1570
1571   if (IsEqualGUID(riid, &IID_IUnknown)
1572       || IsEqualGUID(riid, &IID_IDirectXFileObject))
1573   {
1574     IClassFactory_AddRef(iface);
1575     *ppvObject = This;
1576     return S_OK;
1577   }
1578
1579   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1580   return E_NOINTERFACE;
1581 }
1582
1583 static ULONG WINAPI IDirectXFileObjectImpl_AddRef(IDirectXFileObject* iface)
1584 {
1585   IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
1586   ULONG ref = InterlockedIncrement(&This->ref);
1587
1588   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1589
1590   return ref;
1591 }
1592
1593 static ULONG WINAPI IDirectXFileObjectImpl_Release(IDirectXFileObject* iface)
1594 {
1595   IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
1596   ULONG ref = InterlockedDecrement(&This->ref);
1597
1598   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1599
1600   if (!ref)
1601     HeapFree(GetProcessHeap(), 0, This);
1602
1603   return ref;
1604 }
1605
1606 /*** IDirectXFileObject methods ***/
1607 static HRESULT WINAPI IDirectXFileObjectImpl_GetName(IDirectXFileObject* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1608 {
1609   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1610
1611   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1612
1613   return DXFILEERR_BADVALUE;
1614 }
1615
1616 static HRESULT WINAPI IDirectXFileObjectImpl_GetId(IDirectXFileObject* iface, LPGUID pGuid)
1617 {
1618   IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
1619
1620   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1621
1622   return DXFILEERR_BADVALUE;
1623 }
1624
1625 static const IDirectXFileObjectVtbl IDirectXFileObject_Vtbl =
1626 {
1627     IDirectXFileObjectImpl_QueryInterface,
1628     IDirectXFileObjectImpl_AddRef,
1629     IDirectXFileObjectImpl_Release,
1630     IDirectXFileObjectImpl_GetName,
1631     IDirectXFileObjectImpl_GetId
1632 };
1633
1634 HRESULT IDirectXFileSaveObjectImpl_Create(IDirectXFileSaveObjectImpl** ppObj)
1635 {
1636     IDirectXFileSaveObjectImpl* object;
1637
1638     TRACE("(%p)\n", ppObj);
1639
1640     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileSaveObjectImpl));
1641
1642     object->lpVtbl.lpVtbl = &IDirectXFileSaveObject_Vtbl;
1643     object->ref = 1;
1644
1645     *ppObj = object;
1646
1647     return S_OK;
1648 }
1649
1650 /*** IUnknown methods ***/
1651 static HRESULT WINAPI IDirectXFileSaveObjectImpl_QueryInterface(IDirectXFileSaveObject* iface, REFIID riid, void** ppvObject)
1652 {
1653   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1654
1655   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1656
1657   if (IsEqualGUID(riid, &IID_IUnknown)
1658       || IsEqualGUID(riid, &IID_IDirectXFileSaveObject))
1659   {
1660     IClassFactory_AddRef(iface);
1661     *ppvObject = This;
1662     return S_OK;
1663   }
1664
1665   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1666   return E_NOINTERFACE;
1667 }
1668
1669 static ULONG WINAPI IDirectXFileSaveObjectImpl_AddRef(IDirectXFileSaveObject* iface)
1670 {
1671   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1672   ULONG ref = InterlockedIncrement(&This->ref);
1673
1674   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1675
1676   return ref;
1677 }
1678
1679 static ULONG WINAPI IDirectXFileSaveObjectImpl_Release(IDirectXFileSaveObject* iface)
1680 {
1681   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1682   ULONG ref = InterlockedDecrement(&This->ref);
1683
1684   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1685
1686   if (!ref)
1687     HeapFree(GetProcessHeap(), 0, This);
1688
1689   return ref;
1690 }
1691
1692 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveTemplates(IDirectXFileSaveObject* iface, DWORD cTemplates, const GUID** ppguidTemplates)
1693 {
1694   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1695
1696   FIXME("(%p/%p)->(%d,%p) stub!\n", This, iface, cTemplates, ppguidTemplates);
1697
1698   return DXFILEERR_BADVALUE;
1699 }
1700
1701 static HRESULT WINAPI IDirectXFileSaveObjectImpl_CreateDataObject(IDirectXFileSaveObject* iface, REFGUID rguidTemplate, LPCSTR szName, const GUID* pguid, DWORD cbSize, LPVOID pvData, LPDIRECTXFILEDATA* ppDataObj)
1702 {
1703   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1704
1705   FIXME("(%p/%p)->(%p,%s,%p,%d,%p,%p) stub!\n", This, iface, rguidTemplate, szName, pguid, cbSize, pvData, ppDataObj);
1706
1707   return DXFILEERR_BADVALUE;
1708 }
1709
1710 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveData(IDirectXFileSaveObject* iface, LPDIRECTXFILEDATA ppDataObj)
1711 {
1712   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
1713
1714   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppDataObj);
1715
1716   return DXFILEERR_BADVALUE;
1717 }
1718
1719 static const IDirectXFileSaveObjectVtbl IDirectXFileSaveObject_Vtbl =
1720 {
1721     IDirectXFileSaveObjectImpl_QueryInterface,
1722     IDirectXFileSaveObjectImpl_AddRef,
1723     IDirectXFileSaveObjectImpl_Release,
1724     IDirectXFileSaveObjectImpl_SaveTemplates,
1725     IDirectXFileSaveObjectImpl_CreateDataObject,
1726     IDirectXFileSaveObjectImpl_SaveData
1727 };