- Main Page
- Classes
- Files
- Directories
- Examples

- File List
- File Members

# fbxio.h

Go to the documentation of this file.

    00001 /****************************************************************************************
    00002
    00003    Copyright (C) 2012 Autodesk, Inc.
    00004    All rights reserved.
    00005
    00006    Use of this software is subject to the terms of the Autodesk license agreement
    00007    provided at the time of installation or download, or which otherwise accompanies
    00008    this software in either electronic or hard copy form.
    00009
    00010 ****************************************************************************************/
    00011
    00013 #ifndef _FBXSDK_FILEIO_FBX_IO_H_
    00014 #define _FBXSDK_FILEIO_FBX_IO_H_
    00015
    00016 #include <fbxsdk/fbxsdk_def.h>
    00017
    00018 #include <fbxsdk/core/base/fbxarray.h>
    00019 #include <fbxsdk/core/base/fbxcharptrset.h>
    00020 #include <fbxsdk/core/base/fbxerror.h>
    00021 #include <fbxsdk/core/base/fbxfile.h>
    00022 #include <fbxsdk/core/base/fbxstring.h>
    00023 #include <fbxsdk/core/base/fbxtime.h>
    00024
    00025 #include <fbxsdk/fbxsdk_nsbegin.h>
    00026
    00027 class FBXSDK_DLL FbxXRefManager;
    00028 class FbxReader;
    00029 class FbxWriter;
    00030 class FbxIO;
    00031 class FbxStream;
    00032
    00116 #define FBX_DEFAULT_VERSION_NUMBER 7300
    00117
    00118
    00119 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00120
    00122     enum
    00123     {
    00124         FBX_NO_SECTION = -1,        // indicate not in a valid section
    00125         FBX_MAIN_SECTION,           // indicate currently in the main section
    00126         FBX_EXTENSION_SECTION_0,    // indicate currently in the extention section 0
    00127         // FBX_EXTENSION_SECTION_1,
    00128         // FBX_EXTENSION_SECTION_2,
    00129         // ...
    00130     };
    00131 #endif
    00132
    00136 class FBXSDK_DLL FbxIODefaultRenderResolution
    00137 {
    00138 public:
    00140     bool    mIsOK;
    00142     FbxString mCameraName;
    00144     FbxString mResolutionMode;
    00146     double mResolutionW;
    00148     double mResolutionH;
    00149
    00154
    00155     FbxIODefaultRenderResolution();
    00157
    00162
    00163     void Reset();
    00165 };
    00166
    00171 class FBXSDK_DLL FbxIOFileHeaderInfo
    00172 {
    00173 public:
    00178
    00179     FbxIOFileHeaderInfo();
    00180
    00182     virtual ~FbxIOFileHeaderInfo();
    00184
    00189
    00191     virtual void                Reset();
    00192
    00196     virtual bool                ReadExtendedHeaderInformation(FbxIO*);
    00198
    00200     FbxIODefaultRenderResolution    mDefaultRenderResolution;
    00201
    00203
    00205
    00209     int                         mFileVersion;
    00210
    00212     bool                        mCreationTimeStampPresent;
    00213
    00215     FbxLocalTime                  mCreationTimeStamp;
    00216
    00220     FbxString                     mCreator;
    00221
    00223     bool                        mIOPlugin;
    00224
    00226     bool                        mPLE;
    00228 };
    00229
    00272 class FBXSDK_DLL FbxIO
    00273 {
    00274 public:
    00275
    00278     struct FbxAutoResetXRefManager
    00279     {
    00280         FbxIO*                   mFbx;
    00281         const FbxXRefManager*  mXRefManager;
    00282
    00284         FbxAutoResetXRefManager(FbxIO* pFbx, FbxXRefManager& pXRefManager)
    00285         : mFbx(pFbx)
    00286         , mXRefManager(NULL)
    00287         {
    00288             if( mFbx )
    00289             {
    00290                 mXRefManager = mFbx->ProjectGetXRefManager();
    00291                 mFbx->ProjectSetXRefManager(&pXRefManager);
    00292             }
    00293         }
    00294
    00296         ~FbxAutoResetXRefManager()
    00297         {
    00298             if( mFbx )
    00299             {
    00300                 mFbx->ProjectSetXRefManager(mXRefManager);
    00301             }
    00302         }
    00303     };
    00304
    00308     static FbxIO* Create(){ return FbxNew< FbxIO >(); }
    00309
    00311     FbxIO();
    00312
    00314     virtual ~FbxIO();
    00315
    00322
    00332     bool ProjectOpen(void* pAddress, FbxULong pMaxLength, FbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00333
    00342     bool ProjectOpen(const char* pName, FbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00343
    00344 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00345
    00353     bool ProjectOpen (FbxFile * pFile, FbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00354 #endif
    00355
    00365     bool ProjectOpen(FbxStream* pStream, void* pStreamData, FbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00366
    00375     bool ProjectOpenDirect(const char* pName, FbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00376
    00386     bool ProjectCreate(void* pAddress, FbxUInt pSize, FbxWriter* pWriter, bool pBinary, bool pEncrypted, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00387
    00396     bool ProjectCreate(const char* pName, FbxWriter* pWriter, bool pBinary, bool pEncrypted, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00397
    00407     bool ProjectCreate(FbxStream* pStream, void* pStreamData, FbxWriter* pWriter, bool pBinary, bool pEncrypted, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00408
    00417     bool ProjectCreateDirect(const char* pName, FbxWriter* pWriter, bool pBinary, bool pEncrypted, FbxIOFileHeaderInfo* pFileHeaderInfo = NULL);
    00418
    00427     bool ProjectCreateEmpty(const char* pName, FbxWriter* pWriter, int pVersion, bool pBinary, bool pEncrypted);
    00428
    00438     bool ProjectCreateEmpty(FbxStream* pStream, void* pStreamData, FbxWriter* pWriter, int pVersion, bool pBinary, bool pEncrypted);
    00439
    00443     bool ProjectWrite_BeginFileHeader();
    00444
    00448     bool ProjectWrite_BeginExtendedHeader();
    00449
    00454     bool ProjectWrite_WriteExtendedHeader(const FbxIOFileHeaderInfo* pExtendedHeader);
    00455
    00459     bool ProjectWrite_EndExtendedHeader();
    00460
    00464     bool ProjectWrite_EndFileHeader();
    00465
    00471     bool ProjectClose(void** pData=0, size_t* pSize=0);
    00472
    00476     void ProjectSetXRefManager(const FbxXRefManager*);
    00477
    00481     const FbxXRefManager* ProjectGetXRefManager() const;
    00482
    00497     bool ProjectCreateEmbeddedFolder(const FbxXRefManager& pXRefManager, FbxString& pCreatedFolder, const char* pUserDefinedFolder = NULL);
    00498
    00502     void SetEmbedded(bool pValue);
    00503
    00507     void SetEmbeddingExtractionFolder(const char* pExtractionFolder);
    00508
    00511     const char* GetEmbeddingExtractionFolder();
    00512
    00516     bool IsEmbedded() const;
    00517
    00521     bool IsBinary() const;
    00522
    00526     bool IsEncrypted () const;
    00527
    00531     bool CheckCRC();
    00532
    00536     FbxUInt32 GetFileVersionNumber() const;
    00537
    00541     void CacheSize(FbxUInt32 pCacheSize);
    00542
    00546     FbxUInt32 CacheSize() const;
    00547
    00549
    00560
    00562     bool Fbx7Support() const;
    00563
    00567     void Fbx7Support(bool pSupport);
    00568
    00570     bool CompressArrays() const;
    00571
    00575     void CompressArrays(bool pCompress);
    00576
    00578     int  CompressMinimumSize() const;
    00579
    00583     void CompressMinimumSize(int pSize);
    00584
    00586     int  CompressLevel() const;
    00587
    00593     void CompressLevel(int pLevel);
    00595
    00601
    00605     bool ProjectOpenMainSection();
    00606
    00610     int ProjectGetExtensionSectionCount() const;
    00611
    00616     bool ProjectOpenExtensionSection(int pExtensionSectionIndex);
    00617
    00622     bool ProjectCreateExtensionSection(bool pOverwriteLastExtensionSection = false);
    00623
    00626     void ProjectCloseSection();
    00627
    00631     int ProjectGetCurrentSection() const;
    00632
    00636     int ProjectGetCurrentSectionMode() const;
    00637
    00641     int ProjectGetCurrentSectionVersion() const;
    00642
    00650     int ProjectGetSectionVersion(int pSection) const;
    00651
    00658     static void ProjectConvertVersionNumber(int pVersion, int& pMajor, int& pMinor, int& pRevision);
    00659
    00663     bool IsPasswordProtected() const;
    00664
    00670     bool CheckPassword(const char* pPassword);
    00671
    00678     bool WritePassword(const char* pPassword);
    00679
    00681
    00686
    00690     const char* GetFilename() const;
    00691
    00696     FbxString GetDataDirectory(bool pAutoCreate = true);
    00697
    00706     FbxString GetMediaDirectory(bool pCreate = false, const char* pUserDefinedFolder = NULL);
    00707
    00713     FbxString GetContainerTemplateDirectory(const char* pTemplateName, bool pCreate);
    00714
    00719     char* GetRelativePath(const char* pPath);
    00720
    00725     char* GetRelativeFilePath(const char* pFilePath);
    00726
    00731     char* GetFullPath(const char* pRelativePath);
    00732
    00737     char* GetFullFilePath(const char* pRelativeFilePath);
    00738
    00743     char* GetTmpProjectName(const char* pName) const;
    00744
    00751     bool SwapFromTmpProject(const char* pName, char* pError=NULL, int pErrorSize=0);
    00752
    00754
    00760
    00763     void FieldReadResetPosition();
    00764
    00768     int FieldGetCount() const;
    00769
    00774     const char* FieldGetName(int pFieldIndex) const;
    00775
    00780     int FieldGetInstanceCount(const char* pFieldName) const;
    00781
    00787     bool FieldReadBegin(int pFieldIndex, int pInstance);
    00788
    00793     bool FieldReadBegin(const char* pFieldName);
    00794
    00800     bool FieldReadBegin(const char* pFieldName, int pInstance);
    00801
    00803     void FieldReadEnd();
    00804
    00806     bool FieldReadIsBlock();
    00807
    00809     bool FieldReadBlockBegin();
    00810
    00812     void FieldReadBlockEnd();
    00813
    00815     int FieldReadGetCount() const;
    00816
    00818     int FieldReadGetRemain() const;
    00819
    00821     char FieldReadGetType() const;
    00822
    00824     char FieldReadCH();
    00825
    00830     char FieldReadCH(const char* pFieldName, char pDefault=0);
    00831
    00833     const char* FieldReadC();
    00834
    00839     const char* FieldReadC(const char* pFieldName, const char* pDefault="");
    00840
    00842     const char* FieldReadS();
    00843
    00848     const char* FieldReadS(const char* pFieldName, const char* pDefault="");
    00849
    00851     bool FieldReadB();
    00852
    00857     bool FieldReadB(const char* pFieldName, bool pDefault = false);
    00858
    00860     int FieldReadI();
    00861 int FieldReadI(const char* pFieldName, int pDefault=0);
    00866
    00868     FbxLongLong FieldReadLL();
    00869
    00874     FbxLongLong FieldReadLL(const char* pFieldName, FbxLongLong pDefault=0);
    00875
    00877     float FieldReadF();
    00878
    00883     float FieldReadF(const char* pFieldName, float pDefault=0);
    00884
    00886     double FieldReadD();
    00887
    00892     double FieldReadD(const char* pFieldName, double pDefault=0);
    00893
    00897     FbxTime FieldReadT(const char* pFieldName);
    00898
    00900     FbxTime FieldReadT();
    00901
    00905     FbxTimeSpan FieldReadTS(const char* pFieldName);
    00906
    00908     FbxTimeSpan FieldReadTS();
    00909
    00914     void FieldReadFn(float* pValue, FbxUInt pn);
    00915
    00919     void FieldRead3F(float* pValue);
    00920
    00924     void FieldRead4F(float* pValue);
    00925
    00932     void FieldReadFn(const char* pFieldName, float* pValue, const float *pDefault, FbxUInt pn);
    00933
    00939     void FieldRead3F(const char* pFieldName, float* pValue, const float* pDefault=NULL);
    00940
    00946     void FieldRead4F(const char* pFieldName, float* pValue, const float* pDefault=NULL);
    00947
    00952     void FieldReadDn(double* pValue, FbxUInt pn);
    00953
    00957     void FieldRead3D(double* pValue);
    00958
    00962     void FieldRead4D(double* pValue);
    00963
    00970     void FieldReadDn(const char* pFieldName, double* pValue, const double *pDefault, FbxUInt pn);
    00971
    00977     void FieldRead3D(const char* pFieldName, double* pValue, const double* pDefault=NULL);
    00978
    00984     void FieldRead4D(const char* pFieldName, double* pValue, const double* pDefault=NULL);
    00985
    00989     void* FieldReadR(int* pByteSize);
    00990
    00995     void* FieldReadR(const char* pFieldName,int* pByteSize);
    00996
    01001
    01002     FbxChar FieldReadByte();
    01003
    01008     FbxChar FieldReadByte(const char* pFieldName, FbxChar pDefault=0);
    01009
    01011     FbxUChar FieldReadUByte();
    01012
    01017     FbxUChar FieldReadUByte(const char* pFieldName, FbxUChar pDefault=0);
    01018
    01020     FbxShort FieldReadShort();
    01021
    01026     FbxShort FieldReadShort(const char* pFieldName, FbxShort pDefault=0);
    01027
    01029     FbxUShort FieldReadUShort();
    01030
    01035     FbxUShort FieldReadUShort(const char* pFieldName, FbxUShort pDefault=0);
    01036
    01038     unsigned int FieldReadUI();
    01039
    01044     unsigned int FieldReadUI(const char* pFieldName, unsigned int pDefault=0);
    01045
    01047     FbxULongLong FieldReadULL();
    01048
    01053     FbxULongLong FieldReadULL(const char* pFieldName, FbxULongLong pDefault=0);
    01054
    01058     const FbxChar*      FieldReadArraySBytes( int &pCount );
    01062     const FbxShort*     FieldReadArrayShort ( int &pCount );
    01066     const FbxUShort*        FieldReadArrayUShort( int &pCount );
    01070     const unsigned int* FieldReadArrayUI    ( int &pCount );
    01074     const FbxULongLong* FieldReadArrayULL   ( int &pCount );
    01075
    01079     const FbxChar*        FieldReadArray(int &pCount, const FbxChar*);
    01086     const FbxShort*     FieldReadArray(int &pCount, const FbxShort*);
    01090     const FbxUShort*        FieldReadArray(int &pCount, const FbxUShort*);
    01094     const unsigned int* FieldReadArray(int &pCount, const unsigned int*);
    01098     const FbxULongLong* FieldReadArray(int &pCount, const FbxULongLong*);
    01100
    01109     virtual bool FieldReadEmbeddedFile (FbxString& pFileName, FbxString& pRelativeFileName, const char* pEmbeddedMediaDirectory = "", bool *pIsFileCreated=NULL);
    01110
    01114     const double*   FieldReadArrayD( int &pCount );
    01118     const float*    FieldReadArrayF( int &pCount );
    01122     const int*      FieldReadArrayI( int &pCount );
    01126     const FbxLongLong*FieldReadArrayLL(int &pCount );
    01130     const bool*     FieldReadArrayB( int &pCount );
    01134     const FbxUChar*   FieldReadArrayBytes( int &pCount );
    01135
    01139     const int*    FieldReadArray(int& pCount, const int*);
    01143     const float*  FieldReadArray(int& pCount, const float*);
    01147     const double* FieldReadArray(int& pCount, const double*);
    01151     const FbxLongLong* FieldReadArray(int& pCount, const FbxLongLong*);
    01155     const bool* FieldReadArray(int& pCount, const bool*);
    01159     const FbxUChar* FieldReadArray(int& pCount, const FbxUChar*);
    01160
    01162
    01168
    01172     void FieldWriteBegin(const char* pFieldName);
    01173
    01175     void FieldWriteEnd();
    01176
    01178     void FieldWriteBlockBegin();
    01179
    01185     void FieldWriteObjectBegin(const char* pObjectType, const char* pName, const char* pSubType=NULL);
    01186
    01188     void FieldWriteObjectEnd();
    01189
    01194     void FieldWriteBlockBegin(const char* pFileName);
    01195
    01197     void FieldWriteBlockEnd ();
    01198
    01202     void FieldWriteCH(char pValue);
    01203
    01208     void FieldWriteCH(const char* pFieldName, char pValue);
    01209
    01213     void FieldWriteC(const char* pValue);
    01214
    01219     void FieldWriteC(const char* pFieldName, const char* pValue);
    01220
    01224     void FieldWriteS(const char* pValue);
    01225
    01229     void FieldWriteS(const FbxString& pValue);
    01230
    01235     void FieldWriteS(const char* pFieldName, const char* pValue);
    01236
    01241     void FieldWriteS(const char* pFieldName, const FbxString& pValue);
    01242
    01246     void FieldWriteB(bool pValue);
    01247
    01252     void FieldWriteB(const char* pFieldName, bool pValue);
    01253
    01257     void FieldWriteI(int pValue);
    01258
    01263     void FieldWriteI(const char* pFieldName, int pValue);
    01264
    01268     void FieldWriteLL(FbxLongLong pValue);
    01269
    01274     void FieldWriteLL(const char* pFieldName, FbxLongLong pValue);
    01275
    01280     void FieldWriteF(float pValue);
    01281
    01287     void FieldWriteF(const char* pFieldName, float pValue);
    01288
    01292     void FieldWriteD(double  pValue);
    01293
    01298     void FieldWriteD(const char* pFieldName, double pValue);
    01299
    01303     void FieldWriteT(FbxTime pTime);
    01304
    01309     void FieldWriteT(const char* pFieldName,FbxTime pValue);
    01310
    01314     void FieldWriteTS(FbxTimeSpan pTimeSpan);
    01315
    01320     void FieldWriteTS(const char* pFieldName,FbxTimeSpan pValue);
    01321
    01326     void FieldWriteFn(const float* pValue, FbxUInt pn);
    01327
    01333     void FieldWriteFn(const char* pFieldName, const float* pValue, FbxUInt pn);
    01334
    01338     void FieldWrite3F(const float* pValue);
    01339
    01344     void FieldWrite3F(const char* pFieldName, const float* pValue);
    01345
    01349     void FieldWrite4F(const float* pValue);
    01350
    01355     void FieldWrite4F(const char* pFieldName, const float* pValue);
    01356
    01361     void FieldWriteDn(const double* pValue, FbxUInt pn);
    01362
    01368     void FieldWriteDn(const char* pFieldName, const double* pValue, FbxUInt pn);
    01369
    01373     void FieldWrite3D(const double* pValue);
    01374
    01379     void FieldWrite3D(const char* pFieldName, const double* pValue);
    01380
    01384     void FieldWrite4D(const double* pValue);
    01385
    01390     void FieldWrite4D(const char* pFieldName, const double* pValue);
    01391
    01392     // The maximum number of value entries is, in theory, 2**32.  In practice it should be a lot less than that.
    01393     // pSize is the number of values to write from each pointer location, and stride is how much we
    01394     // advance to get to the next value; if the stride is zero, values are tighly packed together.
    01395     // So in total we'll write n * pSize items.
    01396
    01403     void FieldWriteArrayD( int n, const double*     pValue, int pSize = 1, int pStride = 0 );
    01410     void FieldWriteArrayF( int n, const float*      pValue, int pSize = 1, int pStride = 0 );
    01417     void FieldWriteArrayI( int n, const int*        pValue, int pSize = 1, int pStride = 0 );
    01424     void FieldWriteArrayLL(int n, const FbxLongLong*  pValue, int pSize = 1, int pStride = 0 );
    01431     void FieldWriteArrayB( int n, const bool*       pValue, int pSize = 1, int pStride = 0 );
    01438     void FieldWriteArrayBytes( int n, const FbxUChar* pValue, int pSize = 1, int pStride = 0 );
    01439
    01444     void FieldWriteR(const void* pRawData, int pByteSize);
    01445
    01451     void FieldWriteR(const char* pFieldName, const void* pRawData, int pByteSize);
    01452
    01457
    01461     void FieldWriteByte(FbxChar pValue);
    01462
    01467     void FieldWriteByte(const char* pFieldName, FbxChar pValue);
    01468
    01472     void FieldWriteUByte(FbxUChar pValue);
    01473
    01478     void FieldWriteUByte(const char* pFieldName, FbxUChar pValue);
    01479
    01483     void FieldWriteShort(FbxShort pValue);
    01484
    01489     void FieldWriteShort(const char* pFieldName, FbxShort pValue);
    01490
    01494     void FieldWriteUShort(FbxUShort pValue);
    01495
    01500     void FieldWriteUShort(const char* pFieldName, FbxUShort pValue);
    01501
    01505     void FieldWriteUI(unsigned int pValue);
    01506
    01511     void FieldWriteUI(const char* pFieldName, unsigned int pValue);
    01512
    01516     void FieldWriteULL(FbxULongLong pValue);
    01517
    01523     void FieldWriteULL(const char* pFieldName, FbxULongLong pValue);
    01524
    01531     void FieldWriteArraySBytes( int n, const FbxChar* pValue, int pSize = 1, int pStride = 0 );
    01538     void FieldWriteArrayShort( int n, const FbxShort* pValue, int pSize = 1, int pStride = 0 );
    01545     void FieldWriteArrayUShort( int n, const FbxUShort* pValue, int pSize = 1, int pStride = 0 );
    01552     void FieldWriteArrayUI( int n, const unsigned int*        pValue, int pSize = 1, int pStride = 0 );
    01559     void FieldWriteArrayULL(int n, const FbxULongLong*  pValue, int pSize = 1, int pStride = 0 );
    01561
    01565     int GetFieldRMaxChunkSize() const;
    01566
    01570     void FieldWriteObjectReference(const char* pName);
    01571
    01576     void FieldWriteObjectReference(const char* pFieldName, const char* pName);
    01577
    01584     bool FieldWriteEmbeddedFile (FbxString pFileName, FbxString pRelativeFileName);
    01585
    01589     void WriteComments(const char* pFieldName);
    01590
    01592
    01598
    01600     enum EErrorCode
    01601     {
    01602         eFileCorrupted,
    01603         eFileVersionNotSupportedYet,
    01604         eFileVersionNotSupportedAnymore,
    01605         eFileNotOpened,
    01606         eFileNotCreated,
    01607         eDirectoryNotCreated,
    01608         eCrcCheckFailed,
    01609         eNonExistingSection,
    01610         eOperationCanceled,
    01611         eCountError,
    01612         eInvalidData,
    01613         eWriteError,
    01614         eReadError,
    01615         eErrorCount
    01616     };
    01617
    01621     FbxError& GetError();
    01622
    01626     EErrorCode GetLastErrorID() const;
    01627
    01631     const char* GetLastErrorString() const;
    01632
    01634
    01635 #ifdef _DEBUG
    01636     // Dump function for debugging purpose only
    01637     void StdoutDump();
    01638 #endif
    01639
    01647     bool GetHaveLoadedEmbededFile() const;
    01648
    01653     void GetMemoryFileInfo(void** pMemPtr, size_t& pSize) const;
    01654
    01655 public:
    01656
    01660     bool    IsBeforeVersion6() const;
    01661
    01665     void    SetIsBeforeVersion6(bool pIsBeforeVersion6);
    01666
    01667 private:
    01668     struct Implementation;
    01669     Implementation* mImpl;
    01670
    01672
    01673     void ProjectClear();
    01674     void ProjectReset();
    01675
    01676     bool ProjectReadHeader(bool pCheckASCIIHeader, bool pCheckCRC, bool pOpenMainSection, FbxIOFileHeaderInfo* pFileHeaderInfo);
    01677     bool ProjectReadExtendedHeader(int& pExtendedHeaderEnd, FbxIOFileHeaderInfo* pFileHeaderInfo);
    01678     bool BinaryReadHeader();
    01679     bool BinaryReadSectionPosition();
    01680     bool ASCIIReadHeader();
    01681     bool ASCIIReadSectionPosition();
    01682
    01683     bool ProjectWriteHeader(FbxIOFileHeaderInfo* pFileHeaderInfo);
    01684     bool ProjectWriteExtendedHeader(FbxIOFileHeaderInfo* pFileHeaderInfo);
    01685     void BinaryWriteHeader();
    01686     void ASCIIWriteHeader();
    01687
    01688     void ReadEncryptionKey(char* pEncryptionKey);
    01689     void WriteEncryptionKey(char* pEncryptionKey);
    01690
    01692
    01693     bool ProjectClearSection();
    01694     bool ProjectOpenSection(int pSection);
    01695     bool BinaryReadSectionHeader();
    01696     int BinaryReadSectionFooter(char* pSourceCheck);
    01697     bool BinaryReadExtensionCode(FbxUInt32 pFollowingSectionStart, FbxUInt32& pSectionStart, FbxUInt32& pSectionVersion);
    01698     void BinaryReadSectionPassword();
    01699
    01700     bool ProjectWriteSectionHeader();
    01701     void BinaryWriteSectionFooter();
    01702     bool BinaryWriteExtensionCode(FbxUInt32 pSectionStart, FbxUInt32 pSectionVersion);
    01703
    01704     FbxString GetCreationTime() const;
    01705     void SetCreationTime(FbxString pCreationTime);
    01706     void CreateSourceCheck(char* lSourceCheck);
    01707     bool TestSourceCheck(char* pSourceCheck, char* pSourceCompany);
    01708     FbxString GetMangledCreationTime();
    01709     void EncryptSourceCheck(char* pSourceCheck, char* pEncryptionData);
    01710     void DecryptSourceCheck(char* pSourceCheck, const char* pEncryptionData);
    01711
    01712     void EncryptPasswordV1(FbxString pOriginalPassword, FbxString &pEncryptedPassword);
    01713     void DecryptPasswordV1(FbxString pEncryptedPassword, FbxString &pDecryptedPassword);
    01714
    01716
    01717     void CheckValidityOfFieldName(const char* pFieldName);
    01718     void GetUnusedEmbeddedName(const FbxString& pDirectory, const FbxString& pName, FbxString& pResult, bool pCreateSubdirectory);
    01719
    01721     FbxString GetDirectory(bool pAutoCreate, const char* pExtension);
    01722 };
    01723
    01724 #include <fbxsdk/fbxsdk_nsend.h>
    01725
    01726 #endif /* _FBXSDK_FILEIO_FBX_IO_H_ */