ktime.h

Go to the documentation of this file.

#ifndef _FBXSDK_KTIME_H_
#define _FBXSDK_KTIME_H_

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

 Copyright © 1999 - 2007 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 <kbaselib_h.h>

#include <kbaselib_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


    class KBASELIB_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_DROP        = 13,
            eTIME_MODE_COUNT    = 14
        };

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

        static void SetGlobalTimeMode(ETimeMode pTimeMode);

        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
        );

        void SetTime 
        (
            int pHour, 
            int pMinute, 
            int pSecond, 
            int pFrame, 
            int pField, 
            int pResidual, 
            int pTimeMode
        );

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

        // Return a Time Snapped on the NEAREST(rounded) Frame (if asked)
        KTime   GetFramedTime(bool pRound = true);

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

        kLongLong GetResidual(int pTimeMode=eDEFAULT_MODE) const;

        char* GetTimeString 
        (
            char* pTimeString,  
            int pInfo=5, 
            int pTimeMode=eDEFAULT_MODE, 
            int pTimeFormat=eDEFAULT_PROTOCOL
        ) const;

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


     
        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);}


    //
    //  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;

    #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
        
        // Global Friend Function
        friend KBASELIB_DLL KTime::ETimeMode KTime_GetGlobalTimeMode();
        friend KBASELIB_DLL KTime::ETimeProtocol KTime_GetGlobalTimeFormat();
        friend KBASELIB_DLL void    KTime_SetGlobalTimeMode( KTime::ETimeMode pTimeMode );
        friend KBASELIB_DLL void    KTime_SetGlobalTimeFormat( KTime::ETimeProtocol pTimeFormat );

    };


    #define KTS_FORWARD 1
    #define KTS_BACKWARD -1


    class KBASELIB_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

    };

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

    // 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 <kbaselib_nsend.h>

#endif // #ifndef _FBXSDK_KTIME_H_