kfbx.h

Go to the documentation of this file.

#ifndef FBXFILESDK_COMPONENTS_KBASELIB_KFBX_KFBX_H
#define FBXFILESDK_COMPONENTS_KBASELIB_KFBX_KFBX_H

/**************************************************************************************

 Copyright (C) 2001 - 2009 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.

 The coded instructions, statements, computer programs, and/or related material 
 (collectively the "Data") in these files contain unpublished information 
 proprietary to Autodesk, Inc. and/or its licensors, which is protected by 
 Canada and United States of America federal copyright law and by international 
 treaties. 
 
 The Data may not be disclosed or distributed to third parties, in whole or in
 part, without the prior written consent of Autodesk, Inc. ("Autodesk").

 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR ARISING
 BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES OF TITLE, 
 NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR USE. 
 WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT WARRANT THAT THE OPERATION
 OF THE DATA WILL BE UNINTERRUPTED OR ERROR FREE. 
 
 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR EXPENSES
 OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE DAMAGES OR OTHER
 SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS OF PROFITS, REVENUE
 OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR DAMAGES OF ANY KIND),
 HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF LIABILITY, WHETHER DERIVED
 FROM CONTRACT, TORT (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE), OR OTHERWISE,
 ARISING OUT OF OR RELATING TO THE DATA OR ITS USE OR ANY OTHER PERFORMANCE,
 WHETHER OR NOT AUTODESK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS
 OR DAMAGE. 

**************************************************************************************/

#include <fbxfilesdk/components/kbaselib/kbaselib_h.h>

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#include <fbxfilesdk/components/kbaselib/klib/kstring.h>
#include <fbxfilesdk/components/kbaselib/klib/ktime.h>
#include <fbxfilesdk/components/kbaselib/klib/kerror.h>
#include <fbxfilesdk/components/kbaselib/klib/karrayul.h>
#include <fbxfilesdk/components/kbaselib/klib/ksystemtime.h>
#include <fbxfilesdk/components/kbaselib/klib/kcharptrset.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

class KFBX_DLL KFbxXRefManager;
class KFile;
class KFbxReader;
class KFbxWriter;

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#include <fbxfilesdk/components/kbaselib/kbaselib_forward.h>
#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

    // Defines the current version number.
    // Please keep this version journal updated.


    #define FBX_DEFAULT_VERSION_NUMBER 6100

    #define FBX7_DEFAULT_VERSION_NUMBER 7000


    // Defines the current version number.
    // Please keep this version journal updated.

    // Version 2000
    // New Bob KFCurve and embedded FBX.; no FCurve/FCurve node storing
    // No more .takf must has been created in an earlier version, no history
    // Ben's data is saved and retrieve

    // Version 2001
    // Version incremented to support KTime save in native (integer, not double!) format.

    // Version 3000
    // FiLMBOX 3.0 version, nothing changed in current class since version 2001.
    // FBX SDK 3.0 and 3.6
    // Ben's data is retrieve only to keep compatibility

    // Version 3001
    // FiLMBOX 3.0 encrypted version, only a trial.
    // Encrypted files could only be written in debug versions.

    // Gross big fat mistake! Cannot switch to a higher version number now because any
    // file with a version number >= 3001 is read as encrypted.
    // Hence, this value now only gives file type. (3000 or less -> binary, 3001 or more -> encrypted)

    // FiLMBOX 3.2, FiLMBOX 3.5 and Online 3.51 have been released with version 3000.

    // Version 4000
    // MotionBuilder 4.0, new type in KFCurve tangents, supported in FiLMBOX 3.5 but not by earlier versions.
    // Version number is now stored in section footer.
    // Before September 3rd 2002, the version number was always 3000 in main section footer.
    // Now the main section footer has version number 4000.
    // The minimum version number in footer of an extension section is 4000.

    // Version 4001
    // ASCII Header is 4.1 !!!!
    // MotionBuilder 4.01, to fix FCurveNode problem with layertypes in version 4000
    // Now the main section footer has version number 4001.
    // Now the footer for extension sections has version number 4001.

    // Version 4050
    // ASCII Header is 4.5 !!!!
    // MotionBuilder 4.1 or 4.5 (we dont know yet) before January 22nd 2003
    // This is because EvaluationProperties now have color.
    // Now the main section footer has version number 4050.
    // Now the footer for extension sections has version number 4050.

    // Version 5000
    // ASCII Header is not compatible anymore with MotionBuilder 4.0, 4.01 and 4.02 and FBX SDK 3.6 and 3.7
    // MotionBuilder 4.03 and 4.1 or 4.5 (we dont know yet) from January 22nd 2003
    // FBX SDK 3.6.1
    // New extended header to improve FBX file version management.
    // Now the extended header and the main section footer have version number 5000.
    // Now the footer for extension sections has version number 5000.

    // ************************************************************************************************
    // ************************************************************************************************
    // ***********************                                                    *********************
    // Version 5800
    // THIS IS A TEMPORARY VERSION WHILE WAITING FOR THE VERSION 6000 which will render the previous
    // versions incompatible with MotionBuilder 6.0. For now, however, this format is needed to allow
    // some tools/plugins (ex:maya) to correctly detect that the file has some features that are not
    // totally backward compatible (ex: pivots defined with _pre/_post nodes which require a special
    // processing). By incrementing only the minor version we do not compromise the integrity of the
    // files.
    // ***********************                                                    *********************
    // ************************************************************************************************
    // ************************************************************************************************

    // Version 6000
    // Header version is now 6.0
    // Extended header now contain a creation time stamp that can be retrieve without parsing the
    // main section of the file.
    // A creator tag (string) is now stored in the Extended header. This contain the originator (MB/FBXSDK)
    // of the file and the build number of the originator.
    // First release of the file format using the KProperties to store/retrieve information.


    // Version 6100
    // Add support for multiple attributes (mainly multiple geometry) at the node level.
    // The pointer to the node attribute have been replaced by a connection between the node and its attribute(s).

    // Version 7000
    // First version of the 7.0 series; most likely very short-lived, developped for Protein, before ADP.
    // Supports reference cloning, external documents, blobs, unique IDs (per file), property templates.
    // So many changes that it was decided to break from 6.0 to keep Motion Builder intact.

    enum
    {
        FBX_NO_SECTION = -1,
        FBX_MAIN_SECTION,
        FBX_EXTENSION_SECTION_0,
        // FBX_EXTENSION_SECTION_1,
        // FBX_EXTENSION_SECTION_2,
        // ...
    };

    class KFBX_DLL KDefaultRenderResolution
    {
    public:
        bool    mIsOK;
        KString mCameraName;
        KString mResolutionMode;
        double mResolutionW;
        double mResolutionH;


        KDefaultRenderResolution();


        void Reset();
    };

    class KFBX_DLL KFbxFileHeaderInfo
    {
    public:

        KFbxFileHeaderInfo();

        virtual ~KFbxFileHeaderInfo();

        virtual void                Reset();

        // Derived classes can get funky and read more info out of the header.
        // Return false in case of failure that should stop loading the file.
        virtual bool                ReadExtendedHeaderInformation(KFbx*);

        KDefaultRenderResolution    mDefaultRenderResolution;

        //Read only properties (not used for file write)

        int                         mFileVersion;

        bool                        mCreationTimeStampPresent;

        kLocalTime                  mCreationTimeStamp;

        KString                     mCreator;               

        bool                        mIOPlugin;


        bool                        mPLE;
    };

    class KFBX_DLL KFbx
    {
    public:
        // Exception-safe way of setting/resetting the xref manager in a KFbx object.
        struct KFbxAutoResetXRefManager
        {
            KFbx*                   mFbx;
            const KFbxXRefManager*  mXRefManager;

            KFbxAutoResetXRefManager(KFbx* pFbx, KFbxXRefManager& pXRefManager)
            : mFbx(pFbx)
            , mXRefManager(NULL)
            {
                if( mFbx )
                {
                    mXRefManager = mFbx->ProjectGetXRefManager();
                    mFbx->ProjectSetXRefManager(&pXRefManager);
                }
            }

            ~KFbxAutoResetXRefManager()
            {
                if( mFbx )
                {
                    mFbx->ProjectSetXRefManager(mXRefManager);
                }
            }
        };


        static KFbx* KFbxObjectCreate(){ return new KFbx; }

        KFbx();
        virtual ~KFbx();


        bool ProjectOpen(void* pAddress, kULong pMaxLength, KFbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectOpen(const char* pName, KFbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectOpen (KFile * pFile, KFbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectOpenDirect(const char* pName, KFbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectCreate(void* pAddress, kUInt pSize, KFbxWriter* pWriter, bool pBinary, bool pEncrypted, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectCreate(const char* pName, KFbxWriter* pWriter, bool pBinary, bool pEncrypted, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectCreateDirect(const char* pName, KFbxWriter* pWriter, bool pBinary, bool pEncrypted, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectCreateEmpty(const char* pName, KFbxWriter* pWriter, int pVersion, bool pBinary, bool pEncrypted);

        bool ProjectWrite_BeginFileHeader();

        bool ProjectWrite_BeginExtendedHeader();

        bool ProjectWrite_WriteExtendedHeader(const KFbxFileHeaderInfo* pExtendedHeader);

        bool ProjectWrite_EndExtendedHeader();

        bool ProjectWrite_EndFileHeader();

        bool ProjectClose(void** pData=0,kULong *pSize=0);

        void ProjectSetXRefManager(const KFbxXRefManager*);

        const KFbxXRefManager* ProjectGetXRefManager() const;

        bool ProjectCreateEmbeddedFolder(const KFbxXRefManager& pXRefManager, KString& pCreatedFolder); 

        void SetEmbedded(bool pValue);

        bool IsEmbedded() const;

        bool IsBinary() const;

        bool IsEncrypted () const;

        bool CheckCRC();

        kUInt32 GetFileVersionNumber() const; 



        bool Fbx7Support() const;

        void Fbx7Support(bool pSupport);

        bool CompressArrays() const;

        void CompressArrays(bool pCompress);

        int  CompressMinimumSize() const;

        void CompressMinimumSize(int pSize);

        int  CompressLevel() const;

        void CompressLevel(int pLevel);


        bool ProjectOpenMainSection();

        int ProjectGetExtensionSectionCount();

        bool ProjectOpenExtensionSection(int pExtensionSectionIndex);

        bool ProjectCreateExtensionSection(bool pOverwriteLastExtensionSection = false);

        void ProjectCloseSection();

        bool ProjectRemoveLastExtensionSection();

        int ProjectGetCurrentSection();

        int ProjectGetCurrentSectionMode();

        int ProjectGetCurrentSectionVersion();

        int ProjectGetSectionVersion(int pSection);

        static void ProjectConvertVersionNumber(int pVersion, int& pMajor, int& pMinor, int& pRevision);

        bool IsPasswordProtected() const;

        bool CheckPassword(const char* pPassword);

        bool WritePassword(const char* pPassword);



        const char* GetFilename() const;

        KString GetDataDirectory(bool pAutoCreate = true);

        KString GetMediaDirectory(bool pCreate = false);

        KString GetContainerTemplateDirectory(const char* pTemplateName, bool pCreate);

        char* GetRelativePath(const char* pPath);

        char* GetRelativeFilePath(const char* pFilePath);

        char* GetFullPath(const char* pRelativePath);

        char* GetFullFilePath(const char* pRelativeFilePath);

        char* GetTmpProjectName(const char* pName);

        bool SwapFromTmpProject(const char* pName, char* pError=NULL);



        void FieldReadResetPosition();

        int FieldGetCount();

        const char* FieldGetName(int pFieldIndex);

        int FieldGetInstanceCount(const char* pFieldName);

        bool FieldReadBegin(int pFieldIndex, int pInstance);

        bool FieldReadBegin(const char* pFieldName);

        bool FieldReadBegin(const char* pFieldName, int pInstance);

        void FieldReadEnd();

        bool FieldReadIsBlock();

        bool FieldReadBlockBegin();

        void FieldReadBlockEnd();

        int FieldReadGetCount();

        int FieldReadGetRemain();

        char FieldReadGetType();

        char FieldReadCH();

        char FieldReadCH(const char* pFieldName, char pDefault=0);

        const char* FieldReadC();

        const char* FieldReadC(const char* pFieldName, const char* pDefault="");

        const char* FieldReadS();

        const char* FieldReadS(const char* pFieldName, const char* pDefault="");

        bool FieldReadB();

        bool FieldReadB(const char* pFieldName, bool pDefault = false);

        int FieldReadI();
int FieldReadI(const char* pFieldName, int pDefault=0);

        kLongLong FieldReadLL();

        kLongLong FieldReadLL(const char* pFieldName, kLongLong pDefault=0);

        float FieldReadF();

        float FieldReadF(const char* pFieldName, float pDefault=0);

        double FieldReadD();

        double FieldReadD(const char* pFieldName, double pDefault=0);

        KTime FieldReadT(const char* pFieldName);

        KTime FieldReadT();

        KTimeSpan FieldReadTS(const char* pFieldName);

        KTimeSpan FieldReadTS();

        void FieldReadFn(float* pValue, kUInt pn);

        void FieldRead3F(float* pValue);

        void FieldRead4F(float* pValue);

        void FieldReadFn(const char* pFieldName, float* pValue, const float *pDefault, kUInt pn);

        void FieldRead3F(const char* pFieldName, float* pValue, const float* pDefault=NULL);

        void FieldRead4F(const char* pFieldName, float* pValue, const float* pDefault=NULL);

        void FieldReadDn(double* pValue, kUInt pn);

        void FieldRead3D(double* pValue);

        void FieldRead4D(double* pValue);

        void FieldReadDn(const char* pFieldName, double* pValue, const double *pDefault, kUInt pn);

        void FieldRead3D(const char* pFieldName, double* pValue, const double* pDefault=NULL);

        void FieldRead4D(const char* pFieldName, double* pValue, const double* pDefault=NULL);

        void* FieldReadR(int* pByteSize);

        void* FieldReadR(const char* pFieldName,int* pByteSize);


        kByte FieldReadByte();

        kByte FieldReadByte(const char* pFieldName, kByte pDefault=0);

        kUByte FieldReadUByte();

        kUByte FieldReadUByte(const char* pFieldName, kUByte pDefault=0);

        kShort FieldReadShort();

        kShort FieldReadShort(const char* pFieldName, kShort pDefault=0);

        kUShort FieldReadUShort();

        kUShort FieldReadUShort(const char* pFieldName, kUShort pDefault=0);

        unsigned int FieldReadUI();
        
        unsigned int FieldReadUI(const char* pFieldName, unsigned int pDefault=0);

        kULongLong FieldReadULL();

        kULongLong FieldReadULL(const char* pFieldName, kULongLong pDefault=0);

        const kByte*        FieldReadArraySBytes( int &pCount );
        const kShort*       FieldReadArrayShort ( int &pCount );
        const kUShort*      FieldReadArrayUShort( int &pCount );
        const unsigned int* FieldReadArrayUI    ( int &pCount );
        const kULongLong*   FieldReadArrayULL   ( int &pCount );

        const kByte*        FieldReadArray(int &pCount, const kByte*);
        const kShort*       FieldReadArray(int &pCount, const kShort*);
        const kUShort*      FieldReadArray(int &pCount, const kUShort*);
        const unsigned int* FieldReadArray(int &pCount, const unsigned int*);
        const kULongLong*   FieldReadArray(int &pCount, const kULongLong*);

        virtual bool FieldReadEmbeddedFile (KString& pFileName, KString& pRelativeFileName, const char* pEmbeddedMediaDirectory = "", bool *pIsFileCreated=NULL);

        const double*   FieldReadArrayD( int &pCount );
        const float*    FieldReadArrayF( int &pCount );
        const int*      FieldReadArrayI( int &pCount );
        const kLongLong*FieldReadArrayLL(int &pCount );
        const bool*     FieldReadArrayB( int &pCount );
        const kUByte*   FieldReadArrayBytes( int &pCount );

        const int*    FieldReadArray(int& pCount, const int*);
        const float*  FieldReadArray(int& pCount, const float*);
        const double* FieldReadArray(int& pCount, const double*);
        const kLongLong* FieldReadArray(int& pCount, const kLongLong*);
        const bool* FieldReadArray(int& pCount, const bool*);
        const kUByte* FieldReadArray(int& pCount, const kUByte*);



        void FieldWriteBegin(const char* pFieldName);

        void FieldWriteEnd();

        void FieldWriteBlockBegin();

        void FieldWriteObjectBegin(const char* pObjectType, const char* pName, const char* pSubType=NULL);

        void FieldWriteObjectEnd();

        void FieldWriteBlockBegin(const char* pFileName);

        void FieldWriteBlockEnd ();

        void FieldWriteCH(char pValue);

        void FieldWriteCH(const char* pFieldName, char pValue);

        void FieldWriteC(const char* pValue);

        void FieldWriteC(const char* pFieldName, const char* pValue);

        void FieldWriteS(const char* pValue);

        void FieldWriteS(const KString& pValue);

        void FieldWriteS(const char* pFieldName, const char* pValue);

        void FieldWriteS(const char* pFieldName, const KString& pValue);

        void FieldWriteB(bool pValue);

        void FieldWriteB(const char* pFieldName, bool pValue);

        void FieldWriteI(int pValue);

        void FieldWriteI(const char* pFieldName, int pValue);

        void FieldWriteLL(kLongLong pValue);

        void FieldWriteLL(const char* pFieldName, kLongLong pValue);

        void FieldWriteF(float pValue);

        void FieldWriteF(const char* pFieldName, float pValue);

        void FieldWriteD(double  pValue);

        void FieldWriteD(const char* pFieldName, double pValue);

        void FieldWriteT(KTime pTime);

        void FieldWriteT(const char* pFieldName,KTime pValue);

        void FieldWriteTS(KTimeSpan pTimeSpan);

        void FieldWriteTS(const char* pFieldName,KTimeSpan pValue);

        void FieldWriteFn(const float* pValue, kUInt pn);

        void FieldWriteFn(const char* pFieldName, const float* pValue, kUInt pn);

        void FieldWrite3F(const float* pValue);

        void FieldWrite3F(const char* pFieldName, const float* pValue);

        void FieldWrite4F(const float* pValue);

        void FieldWrite4F(const char* pFieldName, const float* pValue);

        void FieldWriteDn(const double* pValue, kUInt pn);

        void FieldWriteDn(const char* pFieldName, const double* pValue, kUInt pn);

        void FieldWrite3D(const double* pValue);

        void FieldWrite3D(const char* pFieldName, const double* pValue);

        void FieldWrite4D(const double* pValue);

        void FieldWrite4D(const char* pFieldName, const double* pValue);

        // The maximum number of value entries is, in theory, 2**32.  In practice it should be a lot less than that.
        // pSize is the number of values to write from each pointer location, and stride is how much we 
        // advance to get to the next value; if the stride is zero, values are tighly packed together.
        // So in total we'll write n * pSize items.

        void FieldWriteArrayD( int n, const double*     pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayF( int n, const float*      pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayI( int n, const int*        pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayLL(int n, const kLongLong*  pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayB( int n, const bool*       pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayBytes( int n, const kUByte* pValue, int pSize = 1, int pStride = 0 );

        void FieldWriteR(const void* pRawData, int pByteSize);

        void FieldWriteR(const char* pFieldName, const void* pRawData, int pByteSize);


        void FieldWriteByte(kByte pValue);

        void FieldWriteByte(const char* pFieldName, kByte pValue);

        void FieldWriteUByte(kUByte pValue);

        void FieldWriteUByte(const char* pFieldName, kUByte pValue);

        void FieldWriteShort(kShort pValue);

        void FieldWriteShort(const char* pFieldName, kShort pValue);

        void FieldWriteUShort(kUShort pValue);

        void FieldWriteUShort(const char* pFieldName, kUShort pValue);

        void FieldWriteUI(unsigned int pValue);

        void FieldWriteUI(const char* pFieldName, unsigned int pValue);

        void FieldWriteULL(kULongLong pValue);

        void FieldWriteULL(const char* pFieldName, kULongLong pValue);

        void FieldWriteArraySBytes( int n, const kByte* pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayShort( int n, const kShort* pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayUShort( int n, const kUShort* pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayUI( int n, const unsigned int*        pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayULL(int n, const kULongLong*  pValue, int pSize = 1, int pStride = 0 );

        int GetFieldRMaxChunkSize() const;

        void FieldWriteObjectReference(const char* pName);

        void FieldWriteObjectReference(const char* pFieldName, const char* pName);

        bool FieldWriteEmbeddedFile (KString pFileName, KString pRelativeFileName);

        void WriteComments(const char* pFieldName);



        enum EError
        {
            eFileCorrupted,
            eFileVersionNotSupportedYet,
            eFileVersionNotSupportedAnymore,
            eFileNotOpened,
            eFileNotCreated,
            eDirectoryNotCreated,
            eCrcCheckFailed,
            eNonExistingSection,
            eOperationCanceled,
            eCountError,
            eInvalidData,
            eWriteError,
            eReadError,
            eErrorCount
        };

        KError& GetError();

        EError GetLastErrorID() const;

        const char* GetLastErrorString() const;


    #ifdef _DEBUG
        // Dump function for debugging purpose only
        void StdoutDump();
    #endif

        bool GetHaveLoadedEmbededFile() const;

        void* GetMemoryFileInfo(kULong& pSize);

    public:
        bool    IsBeforeVersion6() const;
        void    SetIsBeforeVersion6(bool pIsBeforeVersion6);

    private:
        struct KFbxImpl;
        KFbxImpl* mImpl;


        void ProjectClear();
        void ProjectReset();

        bool ProjectReadHeader(bool pCheckASCIIHeader, bool pCheckCRC, bool pOpenMainSection, KFbxFileHeaderInfo* pFileHeaderInfo);
        bool ProjectReadExtendedHeader(int& pExtendedHeaderEnd, KFbxFileHeaderInfo* pFileHeaderInfo);
        bool BinaryReadHeader();
        bool BinaryReadSectionPosition();
        bool ASCIIReadHeader();
        bool ASCIIReadSectionPosition();

        bool ProjectWriteHeader(KFbxFileHeaderInfo* pFileHeaderInfo);
        bool ProjectWriteExtendedHeader(KFbxFileHeaderInfo* pFileHeaderInfo);
        void BinaryWriteHeader();
        void ASCIIWriteHeader();

        void ReadEncryptionKey(char* pEncryptionKey);
        void WriteEncryptionKey(char* pEncryptionKey);


        bool ProjectClearSection();
        bool ProjectOpenSection(int pSection);
        bool BinaryReadSectionHeader();
        int BinaryReadSectionFooter(char* pSourceCheck);
        bool BinaryReadExtensionCode(kUInt32 pFollowingSectionStart, kUInt32& pSectionStart, kUInt32& pSectionVersion);
        void BinaryReadSectionPassword();

        bool ProjectWriteSectionHeader();
        void BinaryWriteSectionFooter();
        bool BinaryWriteExtensionCode(kUInt32 pSectionStart, kUInt32 pSectionVersion);

        KString GetCreationTime();
        void SetCreationTime(KString pCreationTime);
        void CreateSourceCheck(char* lSourceCheck);
        bool TestSourceCheck(char* pSourceCheck, char* pSourceCompany);
        KString GetMangledCreationTime();
        void EncryptSourceCheck(char* pSourceCheck, char* pEncryptionData);
        void DecryptSourceCheck(char* pSourceCheck, const char* pEncryptionData);

        void EncryptPasswordV1(KString pOriginalPassword, KString &pEncryptedPassword);
        void DecryptPasswordV1(KString pEncryptedPassword, KString &pDecryptedPassword);


        void CheckValidityOfFieldName(const char* pFieldName);
        void GetUnusedEmbeddedName(const KString& pDirectory, const KString& pName, KString& pResult, bool pCreateSubdirectory);

        KString GetDirectory(bool pAutoCreate, const char* pExtension);
    };

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_COMPONENTS_KBASELIB_KFBX_KFBX_H