Show in Contents

Add to Favorites

Home: FBX SDK Programmers Guide

 

 

 

FBX SDK Reference Guide: ktime.h Source File

Go to the documentation of this file.

#ifndef FBXFILESDK_COMPONENTS_KBASELIB_KLIB_KTIME_H
#define FBXFILESDK_COMPONENTS_KBASELIB_KLIB_KTIME_H

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

 Copyright © 2001 - 2008 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 <fbxfilesdk/fbxfilesdk_nsbegin.h>

    //
    // Basic constants.
    //
    #define KTIME_INFINITE          KTime (K_LONGLONG( 0x7fffffffffffffff))
    #define KTIME_MINUS_INFINITE    KTime (K_LONGLONG(-0x7fffffffffffffff))
    #define KTIME_ZERO              KTime (0)
    #define KTIME_EPSILON           KTime (1)
    #define KTIME_ONE_SECOND        KTime (K_LONGLONG(46186158000))
    #define KTIME_ONE_MINUTE        KTime (K_LONGLONG(2771169480000))
    #define KTIME_ONE_HOUR          KTime (K_LONGLONG(166270168800000))

    #define KTIME_FIVE_SECONDS      KTime (K_LONGLONG(230930790000))
    #define KTIME_ASSERT_EPSILON    0.5

KFBX_FORWARD ( KTimeModeObject );

    class KFBX_DLL KTime 
    {

    public:

        KTime(kLongLong pTime=0) {mTime=pTime;}


        //
        // *** Affected files when adding new enum values ***
        // (ktimeinline.h kfcurveview.cxx, kaudioview.cxx, kvideoview.cxx, kttimespanviewoptical.cxx,
        //  kttimespanview.cxx, ktcameraswitchertimelinecontrol.cxx, fbxsdk(fpproperties.cxx) )
        //
        enum ETimeMode
        {
            eDEFAULT_MODE       = 0,
            eFRAMES120          = 1,
            eFRAMES100          = 2,
            eFRAMES60           = 3,
            eFRAMES50           = 4,
            eFRAMES48           = 5,
            eFRAMES30           = 6,
            eFRAMES30_DROP      = 7,
            eNTSC_DROP_FRAME    = 8,
            eNTSC_FULL_FRAME    = 9,
            ePAL                = 10,
            eCINEMA             = 11,
            eFRAMES1000         = 12,
            eCINEMA_ND      = 13,
            eCUSTOM             = 14,
            eTIME_MODE_COUNT    = 15
        };

        enum ETimeProtocol
        {
            eSMPTE,
            eFRAME,
            eDEFAULT_PROTOCOL,
            eTIME_PROTOCOL_COUNT
        };

        static void SetGlobalTimeMode(ETimeMode pTimeMode, double pFrameRate=0.0);

        static ETimeMode GetGlobalTimeMode();
        
        static void SetGlobalTimeProtocol(ETimeProtocol pTimeProtocol);

        static ETimeProtocol GetGlobalTimeProtocol();

        static double GetFrameRate(ETimeMode pTimeMode);

        static ETimeMode ConvertFrameRateToTimeMode(double pFrameRate, double lPrecision = 0.00000001);

        
        
        inline void Set(kLongLong pTime) {mTime = pTime;}

        inline const kLongLong& Get() const {return mTime;}

        inline void SetMilliSeconds(kLongLong pMilliSeconds) {mTime = pMilliSeconds * K_LONGLONG(46186158);}

        inline kLongLong GetMilliSeconds() const {return mTime / K_LONGLONG(46186158);}

        void SetSecondDouble(double pTime);

        double GetSecondDouble() const;


        void SetTime 
        (
            int pHour, 
            int pMinute, 
            int pSecond, 
            int pFrame = 0, 
            int pField = 0, 
            int pTimeMode=eDEFAULT_MODE,
            double pFramerate = 0.0
        );

        void SetTime 
        (
            int pHour, 
            int pMinute, 
            int pSecond, 
            int pFrame, 
            int pField, 
            int pResidual, 
            int pTimeMode,
            double pFramerate = 0.0
        );

        bool GetTime 
        (
            kLongLong& pHour, 
            kLongLong& pMinute, 
            kLongLong& pSecond, 
            kLongLong& pFrame, 
            kLongLong& pField, 
            kLongLong& pResidual, 
            int pTimeMode=eDEFAULT_MODE,
            double pFramerate = 0.0
        ) const;

        KTime   GetFramedTime(bool pRound = true);

    kLongLong GetHour(bool pCummul=false, int pTimeMode=eDEFAULT_MODE, double pFramerate=0.0) const;
        
    kLongLong GetMinute(bool pCummul=false, int pTimeMode=eDEFAULT_MODE, double pFramerate=0.0) const;
        
    kLongLong GetSecond(bool pCummul=false, int pTimeMode=eDEFAULT_MODE, double pFramerate=0.0) const;
        
    kLongLong GetFrame(bool pCummul=false, int pTimeMode=eDEFAULT_MODE, double pFramerate=0.0) const;
        
    kLongLong GetField(bool pCummul=false, int pTimeMode=eDEFAULT_MODE, double pFramerate=0.0) const;

    kLongLong GetResidual(int pTimeMode=eDEFAULT_MODE, double pFramerate=0.0) const;

        char* GetTimeString 
        (
            char* pTimeString,  
            int pInfo=5, 
            int pTimeMode=eDEFAULT_MODE, 
        int pTimeFormat=eDEFAULT_PROTOCOL,
        double pFramerate = 0.0

        ) const;

    void SetTimeString(char* pTime, int pTimeMode=eDEFAULT_MODE, int pTimeFormat=eDEFAULT_PROTOCOL, double pFramerate = 0.0);


     
        inline bool operator==(const KTime& pTime) const {return mTime == pTime.mTime;}

        inline bool operator!=(const KTime& pTime) const {return mTime != pTime.mTime;}

        inline bool operator>=(const KTime& pTime) const {return mTime >= pTime.mTime;}

        inline bool operator<=(const KTime& pTime) const {return mTime <= pTime.mTime;}

        inline bool operator>(const KTime& pTime) const {return mTime > pTime.mTime;}
     
        inline bool operator<(const KTime& pTime) const {return mTime < pTime.mTime;} 

        inline KTime& operator=(const KTime& pTime) {mTime = pTime.mTime; return *this;}
        
        inline KTime& operator+=(const KTime& pTime) {mTime += pTime.mTime; return *this;}
        
        inline KTime& operator-=(const KTime& pTime) {mTime -= pTime.mTime; return *this;}
        
        KTime operator+(const KTime& pTime) const;

        KTime operator-(const KTime& pTime) const;

        KTime operator*(const int Mult) const;

        KTime operator/(const KTime &pTime) const;

        KTime operator*(const KTime &pTime) const;

        inline KTime &operator++() {mTime += 1; return (*this);}

        inline KTime &operator--() {mTime -= 1; return (*this);}

        static KTime GetSystemTimer();
    //
    //  WARNING!
    //
    //  Anything beyond these lines may not be documented accurately and is 
    //  subject to change without notice.
    //

    #ifndef DOXYGEN_SHOULD_SKIP_THIS

    private:

        kLongLong mTime; // In 1/46, 186, 158, 000 Seconds

        static ETimeMode gsGlobalTimeMode;
        static ETimeProtocol gsGlobalTimeProtocol;
        static KTimeModeObject* gsTimeObject;

    #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
        
        // Global Friend Function
        friend KFBX_DLL KTime::ETimeMode        KTime_GetGlobalTimeMode();
        friend KFBX_DLL HKTimeModeObject        KTime_GetGlobalTimeModeObject();
        friend KFBX_DLL KTime::ETimeProtocol    KTime_GetGlobalTimeFormat();
        friend KFBX_DLL void                    KTime_SetGlobalTimeMode( KTime::ETimeMode pTimeMode, double pFrameRate=0.0 );
        friend KFBX_DLL void                    KTime_SetGlobalTimeFormat( KTime::ETimeProtocol pTimeFormat );

        inline kLongLong GetOneFrameValue ( int pTimeMode, double pFramerate ) const;

    };


    #define KTS_FORWARD 1
    #define KTS_BACKWARD -1

#define KTIMESPAN_INFINITE          KTimeSpan (KTIME_MINUS_INFINITE, KTIME_INFINITE)

    class KFBX_DLL KTimeSpan
    {

    public:

        KTimeSpan() {}

        KTimeSpan(KTime pStart, KTime pStop) {mStart=pStart; mStop=pStop;}

        inline void Set(KTime pStart, KTime pStop) {mStart=pStart; mStop=pStop;}

        inline void SetStart(KTime pStart) {mStart=pStart;}
        
        inline void SetStop(KTime pStop) {mStop=pStop;}
        
        inline KTime &GetStart() {return mStart;}
        
        inline KTime &GetStop() {return mStop;}
        
        inline KTime GetDuration() const {if (mStop>mStart)return mStop-mStart; else return mStart-mStop;}
        
        inline KTime GetSignedDuration() const {return mStop-mStart;}
        
        inline int GetDirection() const {if (mStop>=mStart)return KTS_FORWARD; else return KTS_BACKWARD;}

        bool operator&(KTime &pTime) const;
        
        KTimeSpan operator&(KTimeSpan &pTime) const;

        bool operator!=(KTimeSpan &pTime);

        
    //
    //  WARNING!
    //
    //  Anything beyond these lines may not be documented accurately and is 
    //  subject to change without notice.
    //

    #ifndef DOXYGEN_SHOULD_SKIP_THIS

    private:

        KTime mStart;
        KTime mStop;

    #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

    };



enum EOldTimeMode
{
    eOLD_DEFAULT_MODE,      
    eOLD_CINEMA,            
    eOLD_PAL,               
    eOLD_FRAMES30,          
    eOLD_NTSC_DROP_FRAME,   
    eOLD_FRAMES50,          
    eOLD_FRAMES60,          
    eOLD_FRAMES100,         
    eOLD_FRAMES120,         
    eOLD_NTSC_FULL_FRAME,   
    eOLD_FRAMES30_DROP,     
    eOLD_FRAMES1000,        
    eOLD_TIME_MODE_COUNT
};

class KFBX_DLL KTimeModeObject
{
public:
    double              mFrameRateValue;
    char*               mFrameRateString;
    KTime::ETimeMode    mTimeMode;
    EOldTimeMode        mOldTimeMode;
    char*               mTimeModeString;
    int                 mShowValue;     

    bool                mSystemRate;    
    bool                mExistInOldValue;
    kLongLong           mOneFrameValue;  
};


    KFBX_DLL KTime::ETimeMode KTime_GetGlobalTimeMode ();
KFBX_DLL HKTimeModeObject       KTime_GetGlobalTimeModeObject();
    KFBX_DLL KTime::ETimeProtocol KTime_GetGlobalTimeFormat ();
KFBX_DLL void                   KTime_SetGlobalTimeMode (KTime::ETimeMode pTimeMode, double pFrameRate);
    KFBX_DLL void KTime_SetGlobalTimeFormat (KTime::ETimeProtocol pTimeFormat);
    //
    // Use those functions to keep the compatibility with old timemode since we added new timemode.
    //
    KFBX_DLL int KTime_GetOldTimeModeCorrespondance ( KTime::ETimeMode pNewTimeMode );
    KFBX_DLL int KTime_GetTimeModeFromOldValue ( int pOldTimeMode );
    //
    // We now store the framerate instead of the timemode.
    //
    KFBX_DLL int    KTime_GetTimeModeFromFrameRate   ( char* pFrameRate );
    KFBX_DLL void    KTime_GetControlStringList     ( char* pControlString, KTime::ETimeProtocol pTimeFormat);
    KFBX_DLL char* KTime_GetGlobalFrameRateString ( KTime::ETimeMode pTimeMode );
    KFBX_DLL char* KTime_GetGlobalTimeModeString  ( KTime::ETimeMode pTimeMode );
KFBX_DLL double KTime_GetFrameRate ( KTime::ETimeMode pTimeMode );
    //
    // Time format
    //
    KFBX_DLL int   KTime_SelectionToTimeFormat (int pSelection);
    KFBX_DLL int   KTime_SelectionToTimeMode (int pSelection);
    KFBX_DLL int   KTime_TimeToSelection (int pTimeMode=KTime::eDEFAULT_MODE, int pTimeFormat=KTime::eDEFAULT_PROTOCOL);
    KFBX_DLL char*KTime_GetTimeModeName( int pTimeMode );
    KFBX_DLL int   KTime_GetFrameRateStringListIndex ( KTime::ETimeMode pTimeMode );
KFBX_DLL bool  KTime_IsValidCustomFramerate    ( double pFramerate );
KFBX_DLL bool  KTime_GetNearestCustomFramerate ( double pFramerate, double& pNearestRate );

    // Compatibility Only
    // Ideally, we want to make this go away :)
    #define DEFAULT_MODE    KTime::eDEFAULT_MODE
    #define CINEMA          KTime::eCINEMA
    #define PAL             KTime::ePAL
    #define FRAMES30        KTime::eFRAMES30
    #define NTSC_DROP_FRAME KTime::eNTSC_DROP_FRAME
    #define FRAMES50        KTime::eFRAMES50    
    #define FRAMES60        KTime::eFRAMES60
    #define FRAMES100       KTime::eFRAMES100
    #define FRAMES120       KTime::eFRAMES120
    #define NTSC_FULL_FRAME KTime::eNTSC_FULL_FRAME
    #define FRAMES30_DROP   KTime::eFRAMES30_DROP
    #define FRAMES1000      KTime::eFRAMES1000

    #define TIMEFORMAT_SMPTE  KTime::eSMPTE
    #define TIMEFORMAT_FRAME  KTime::eFRAME
    #define DEFAULT_FORMAT    KTime::eDEFAULT_PROTOCOL

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_COMPONENTS_KBASELIB_KLIB_KTIME_H