---

piave_base.hh

Go to the documentation of this file.

/*
 * PIAVE - PIAVE Is A Video Editor
 *
 * Copyright (C) 2002 Rolf Dubitzky, rolf@dubitzky.de
 *
 */

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */


#if ! defined ( PIAVE_BASE_HH )
#define PIAVE_BASE_HH

// std
#include <unistd.h>
#include <stdint.h>
#include <errno.h>

// std++
#include <iostream>
#include <string>

// For i18n

#ifdef ENABLE_NLS
#  include <libintl.h>
#  undef _
#  define _(String) dgettext (PACKAGE, String)
#  ifdef gettext_noop
#    define N_(String) gettext_noop (String)
#  else
#    define N_(String) (String)
#  endif
#else
#  define textdomain(String) (String)
#  define gettext(String) (String)
#  define dgettext(Domain,Message) (Message)
#  define dcgettext(Domain,Message,Type) (Message)
#  define bindtextdomain(Domain,Directory) (Domain)
#  define _(String) (String)
#  define N_(String) (String)
#endif


/*
 *    some convenience macros
 */
#define ABORT(S)      { std::cerr << __FILE__ << ":" << __LINE__ << " ERROR: " << S << std::endl; abort(); }
#define WARN(S)       { if ( ! PIAVE::Global::quiet ) \
                      std::cerr << __FILE__ << ":" << __LINE__ << " WARNING: " << S << std::endl; }
#define INFO(S)       { if ( PIAVE::Global::verbose && ! PIAVE::Global::quiet  ) \
                      std::cout << __FILE__ << ":" << __LINE__ << " INFO: " << S << std::endl; }
#define ABORT_IF(C,S) { if ( C ) { std::cerr << __FILE__ << ":" << __LINE__ \
                      << " ERROR: (" << #C <<"): "<< S << std::endl; abort(); }}
#define WARN_IF(C,S)  { if ( ! PIAVE::Global::quiet ) \
                      if ( C ) { std::cerr << __FILE__ << ":" << __LINE__ \
                      << " WARNING: (" << #C <<"): " << S << std::endl; }}
#define INFO_IF(C,S)  { if ( PIAVE::Global::verbose && ! PIAVE::Global::quiet  ) \
                      if ( C ) { std::cout << __FILE__ << ":" << __LINE__ \
                      << " INFO: (" << #C <<"): " << S << std::endl; }}

#define PRINTV(C) " "<<#C<<"="<<C

#define PDELETE(P) if ( P!=0 ) { delete P ; P = 0;}

/*
 *
 * \namespace PIAVE
 *
 */
namespace PIAVE {

    class FOURCC;
    class Algorithm;
    class Time;
    class VideoFmt;

    class Global
    {
      public:
        static bool verbose;

        static bool quiet;

        static bool force_decode;

        /* 
         *    this is the format the render tree is working in.
         */
        static VideoFmt renderFmt;


        /*
         *   this should be initialized according
         *   to runtime CPU detection
         */
        static Algorithm * algo;

        // I hate C++ formated IO!!!!!!!!!!!!!!
        static char cbuf[1024];

        static void Init();

        static void Destroy();


        /*
         *   a few small helper functions
         */

        static int hexCharToI( const char a, const char b );

        static void printBackTrace();

        static void fatalSignalHandler( int );
        
    };

    void Init();


    /*
     * \class Time 
     *
     * All time counting is based on seconds at the moment this
     * is not much more than a double with some restrictions, but there might
     * be more things to it in the end..
     *
     */
    class Time
    {
      public:
        Time( double s = 0.0 ) : _sec( s ) {}
        Time( const Time & o ) : _sec( o._sec ) {}
        explicit Time( const std::string & s );

        double sec() const { return _sec; }
        
        const Time operator=( const Time & o ) { _sec = o._sec; return (*this); }
        const Time operator+( const Time & o ) const { return Time( _sec + o._sec ); }
        const Time operator-( const Time & o ) const { return Time( _sec - o._sec ); }
        const double operator*( const Time & o ) const { return _sec * o._sec; }
        const double operator/( const Time & o ) const { return _sec / o._sec; }
        const Time operator+=( const Time & o ) { return _sec += o._sec; }
        const Time operator-=( const Time & o ) { return _sec -= o._sec; }

        bool operator==( const Time & o ) const { 
            return (_sec-0.000001<o._sec)&&(_sec+0.000001>o._sec); }
        bool operator!=( const Time & o ) const { 
            return (_sec-0.000001>o._sec)||(_sec+0.000001<o._sec); }
        bool operator>( const Time & o ) const { return _sec>o._sec; }
        bool operator<( const Time & o ) const { return _sec<o._sec; }
        bool operator>=( const Time & o ) const { return ! (_sec<o._sec); }
        bool operator<=( const Time & o ) const { return ! (_sec>o._sec); }

        std::string toString() const;

        timeval toTimeval() const;

      private:
        double _sec;
    };
    std::ostream& operator<<( std::ostream&, const Time& );


    /*
     *  \class TimeInterval
     *  base for all story elements
     */
    class TimeInterval
    {
      public:
        TimeInterval( Time start=0, Time length=0 ) : 
          _start( start ), _length( length ) {} 
        TimeInterval( const TimeInterval & o ) :
          _start( o.start() ), _length( o.length() ) {};

        Time start()  const { return _start; } 
        Time stop()   const { return _start+_length; }
        Time length() const { return _length; }
        

        Time setStart ( const Time start )   { return _start=start; }
        Time setStop  ( const Time stop )    { if (stop>=_start) _length=stop-_start; return _length; }
        Time setLength( const Time length )  { return _length=length; }

        const TimeInterval & setTime( const TimeInterval & i ) 
            { _start=i.start(); _length=i.length(); return (*this); }
        const TimeInterval & operator=( const TimeInterval & o )
            { setTime( o ); return (*this); }

        bool contains ( const Time t ) const 
            { return (t>=_start && t<_start+_length); }
        TimeInterval intersect( const TimeInterval & t ) const ;
        TimeInterval join( const TimeInterval & t ) const ;
        bool operator==( const TimeInterval & o ) const {
            return _start==o._start && _length==o._length; };
        bool operator!=( const TimeInterval & o ) const {
            return ! operator==( o ); }

        virtual void print( std::ostream & o, int indent ) const;

      private:
        Time _start;
        Time _length;
    };
    std::ostream& operator<<( std::ostream&, const TimeInterval& );

    
    /*
     *  helper algorithm to find the previos property node in a
     *  property path.
     *
     */
    template<class I, class T>
    I
    previous( I first, I last, const T& val)
    {
        I o;
        while ( first != last ) {
            if ( (*first) == val ) return first;
            o = first;
            ++first;
            if ( first == last ) return o;
            if ( (*first) > val ) return o;
        }
            
        return first;
    }

    class Point
    {
      public:
        Point( double x, double y ) : _x( x ), _y( y ) {}
        Point( const Point & p ) : _x( p._x ), _y( p._y ) {}

//         const Point & set( const double x, const double y ) 
//             {_x=x;_y=y;return (*this);}
//         const Point & operator=( const Point & p ) 
//             {_x=x;_y=y;return (*this);}

//         bool operator==( const Point & p ) 
//             {return (p._x==_x&&p._y==y);}
//         bool operator!=( const Point & p ) 
//             {return (p._x!=_x&&p._y==y);}

//         double setx( const double x ) {return _x=x;}
//         double sety( const double y ) {return _y=y;}

        // @{
        double x() const { return _x; }
        double y() const { return _y; }
        // @}

        // @{
        int lx() const;
        int ly() const;
        // @}

      private:
        double _x;
        double _y;
    };

    class Box
    {
      public:
        Box( double x = 0.1 , double y = 0.1 , double w = 0.8 , double h = 0.8 ) :
          _x(x),_y(y),_w(w),_h(h) {}
        Box( Point ul, Point lr ) : 
          _x(ul.x()),_y(ul.y()),_w(lr.x()-ul.x()),_h(lr.y()-ul.y()) {}

        // @{
        double x() const { return _x; }
        double y() const { return _y; }
        double w() const { return _w; }
        double h() const { return _h; }
        double x2() const { return _x+_w; }
        double y2() const { return _y+_h; }
        // @}

        // @{
        // \todo implement antialiasing
        int lx() const;
        int ly() const;
        int lw() const;
        int lh() const;
        int lx2() const;
        int ly2() const;
        // @}

        Point ul() const { return Point( _x,_y ); }
        Point lr() const { return Point( x2(),y2() ); }

      private:
        double _x,_y,_w,_h;

    };
    std::ostream& operator<<( std::ostream&, const Box& );


    class Color 
    {
      public:
        enum Space {
            NONE,
            RGB,
            YUV
        };

        Color( uint8_t a=0, uint8_t b=0, uint8_t c=0, uint8_t d=0 ) {
            _col[0] = a; _col[1] = b; _col[2] = c; _col[3] = d; }
        Color( const std::string & c );

        uint8_t &       operator [] ( uint i )       { return _col[i]; }
        const uint8_t & operator [] ( uint i ) const { return _col[i]; }
        Space space() const { return _space; }
        void  setSpace( Space s ) { _space=s; }

        std::string     toString3() const;
        std::string     toString4() const;
        std::string     toStringA() const;

      private:
        Space _space; // FIXME !! doubles Frame::Colorspace ??
        uint8_t _col[4]; // FIXME use r g b ??? can I save array accesses?

      public:
        static const Color white;
        static const Color black;
        static const Color red;
        static const Color green;
        static const Color blue;
        static const Color yellow;
        static const Color magenta;
        static const Color cyan;
        static const Color transparent_black;
        static const Color transparent_white;
    };
    std::ostream& operator<<( std::ostream&, const Color& );

};

#endif

---