TimeDefs.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef __TIME_DEFS_H 
#define __TIME_DEFS_H 1

#include <stdio.h>

#include "mnstream.h"
#include "MNString.h"
#include "MNValid.h"

/***********************************************************************
 * ParseTimeBase
 ***********************************************************************/

class ParseTimeBase
{
public:
    enum Kind
    {
        SMPTE,
        UTC,
        NPT
    };

private:
    Kind _kind;

    DECLARE_VALID

public:
    ParseTimeBase( Kind k );
    ParseTimeBase( const ParseTimeBase& orig );
    virtual ~ParseTimeBase( );

    const Kind& kind()  const;

    virtual ParseTimeBase* clone( ) const = 0;
    virtual int getAsNptSeconds( ) const = 0;

    virtual void dump( ostream& out ) const = 0;
    virtual MNString toString() const = 0;
};

/***********************************************************************
 * ParseTimeRange
 ***********************************************************************/

class ParseTimeRange
{
    ParseTimeBase* _start;
    ParseTimeBase* _end;
    ParseTimeBase* _defer;

    DECLARE_VALID

public:
    ParseTimeRange( ParseTimeBase* start, ParseTimeBase* end );
    ParseTimeRange( const ParseTimeRange& orig );
    ~ParseTimeRange( );

    void setDeferred( ParseTimeBase* d );
    ParseTimeBase* getDeferred( ) const;

    bool hasStart();
    bool hasEnd();
    bool bDeferred();

    ParseTimeBase* getStart() const;
    ParseTimeBase* getEnd() const;

    int getDurationAsSeconds( ) const;

    void setStart( ParseTimeBase* newStart );

    MNString toString() const;
};

/***********************************************************************
 * ParseTimeSmpte
 ***********************************************************************/

class ParseTimeSmpte : public ParseTimeBase
{
    int _hours;
    int _minutes;
    int _seconds;
    int _frames;
    int _subframes;
public:
    ParseTimeSmpte( const char* text );

    ParseTimeSmpte( int hours,
                    int minutes,
                    int seconds,
                    int frames,
                    int subframes );

    ParseTimeSmpte( const ParseTimeSmpte& orig );

    virtual ~ParseTimeSmpte() { };

    virtual ParseTimeBase* clone( ) const;

    virtual int  getAsNptSeconds( ) const;

    virtual void dump( ostream& out ) const;
    virtual MNString toString( ) const;
};

/***********************************************************************
 * ParseTimeUtc
 ***********************************************************************/

class ParseTimeUtc : public ParseTimeBase
{
    int  _year;
    int  _month;
    int  _day;
    int  _hours;
    int  _minutes;
    int  _seconds;
    int  _fraction;

    bool _good;
public:
    ParseTimeUtc( const char* text );
    ParseTimeUtc( const ParseTimeUtc& orig );
    virtual ~ParseTimeUtc() { };

    virtual ParseTimeBase* clone( ) const;
    virtual int  getAsNptSeconds( ) const;
    virtual void dump( ostream& out ) const;

    int year() const;
    int month() const;
    int day() const;
    int hours() const;
    int minutes() const;
    int seconds() const;
    int fraction() const;
    
    bool good() const;
    virtual MNString toString( ) const;
};

/***********************************************************************
 * ParseTimeNpt
 ***********************************************************************/

class ParseTimeNpt : public ParseTimeBase
{
public:
    enum Type {
        T_SEC,
        T_TIME,
        T_NOW
    };

private:
    int  _hi;
    int  _low;
    bool _now;

public:
    ParseTimeNpt( Type t, const char* text = NULL );
    ParseTimeNpt( const ParseTimeNpt& orig );
    virtual ~ParseTimeNpt() { };

    virtual ParseTimeBase* clone( ) const;
    virtual int  getAsNptSeconds( ) const;
    virtual void dump( ostream& out ) const;
    virtual MNString toString( ) const;
};

/***********************************************************************
 * operator<<
 ***********************************************************************/

ostream& operator<<( ostream& ostr, const ParseTimeBase& t );

/* This is only needed to be compatible with some older functions */

struct SMPTE_TIME
{
        int     hours;
        int     minutes;
        int     seconds;
        int     frames;
        int     subframes;
};

struct SMPTE_RANGE
{
        int     type;
        bool    bStart;
        bool    bEnd;
        struct SMPTE_TIME Start;
        struct SMPTE_TIME End;
};

#define SMPTE_TYPE              1
#define SMPTE_30_DROP_TYPE      2
#define SMPTE_25                4
#endif  

---