ktime.h

Go to the documentation of this file.

#ifndef FBXFILESDK_COMPONENTS_KBASELIB_KLIB_KTIME_H
#define FBXFILESDK_COMPONENTS_KBASELIB_KLIB_KTIME_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/fbxfilesdk_def.h>

#ifdef K_QUICKTIME_PLUGIN
    #ifdef KFBX_DLL
    #undef KFBX_DLL
    #endif
    #define KFBX_DLL
#endif

#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_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 const KTime operator++(int) {KTime lOld = *this; ++(*this); return lOld;}

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

    inline const KTime operator--(int) {KTime lOld = *this; --(*this); return lOld;}

    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

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 time mode since we added new time mode.
//
KFBX_DLL int                    KTime_GetOldTimeModeCorrespondance(KTime::ETimeMode pNewTimeMode);
KFBX_DLL int                    KTime_GetTimeModeFromOldValue(int pOldTimeMode);
//
// We now store the framerate instead of the time mode.
//
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