---

operatorbase.hh

Go to the documentation of this file.

/*
 * PIAVE - PIAVE Is A Video Editor
 *
 * Copyright (C) 2002 Rolf Dubitzky, Rolf.Dubitzky@gmx.net
 *
 */

#if ! defined ( OPERATORBASE_HH )
#define OPERATORBASE_HH

// std
#include <iostream>
#include <string>
#include <sstream>
#include <list>
#include <algorithm>

// piave
#include "piave_base.hh"
#include "storybase.hh"

namespace PIAVE {


    template< class V >
    struct KeyFrame
    {
        KeyFrame( const Time p=0, const V& v = V() ) : pos(p), value( v ) {}
        bool operator <  ( const KeyFrame& o ) const { return pos<o.pos; }
        bool operator >  ( const KeyFrame& o ) const { return pos>o.pos; }
        bool operator == ( const KeyFrame& o ) const { return pos==o.pos; }
        bool operator != ( const KeyFrame& o ) const { return pos!=o.pos; }

        Time pos;
        V value;
    };

    class OpParameterBase
    {
      public:
        OpParameterBase() {};
        
        virtual int  fixMe( int fix_lvl=0 ) = 0;
        virtual void setParameter( const PropertyNode * p ) = 0;

    };


    template< class V >
    class OpParameter : public OpParameterBase
    {
      public:
        OpParameter( const std::string &name, const std::string &type, const V& v ) : 
          _name( name ), 
          _type( type ),
          _isDynamic( false ),
          _hasMin( false ),
          _hasMax( false ),
          _min(),
          _max(),
          _about(),
          _path( 0 )
            { makeNewKeyFrame( 0, v ); };

        typedef          V                                          value_type;
        typedef typename std::list< KeyFrame<V> >::iterator         iterator;
        typedef typename std::list< KeyFrame<V> >::const_iterator   const_iterator;

        void setName( const std::string &name ) { _name = name; };
        void setIsDynamic( bool m=true ) { _isDynamic = m; };
        void setHasMin( bool m=true ) { _hasMin = m; };
        void setHasMax( bool m=true ) { _hasMax = m; };
        void setMin( const V &v ) { _min = v; };
        void setMax( const V &v ) { _max = v; };
        void setAbout( const std::string &about ) { _about = about; };

        std::string getName() const { return _name; }
        bool   getIsDynamic() const { return _isDynamic; }
        bool   getHasMin() const { return _hasMin; }
        bool   getHasMax() const { return _hasMax; }
        V      getMin() const { return _min; }
        V      getMax() const { return _max; }
        std::string getAbout() const { return _about; }

        iterator            pbegin()       { return _path.begin(); }
        const_iterator      pbegin() const { return _path.begin(); }
        iterator            pend()         { return _path.end(); }
        const_iterator      pend()   const { return _path.end(); }
        KeyFrame<V>&        pfront()       { return _path.front(); }
        const KeyFrame<V>&  pfront() const { return _path.front(); }
        KeyFrame<V>&        pback()        { return _path.back(); }
        const KeyFrame<V>&  pback()  const { return _path.back(); }
        int                 psize()  const { return _path.size(); }
        
        bool             removeKeyFrame( Time t );
        KeyFrame<V> *    getKeyFrame( Time t );
        KeyFrame<V> *    makeNewKeyFrame( Time t, const V &v );

        virtual    V     getValue( Time t=0 ) const = 0;

      private:
        std::string     _name;
        std::string     _type;
        bool            _isDynamic;
        bool            _hasMin;
        bool            _hasMax;
        V               _min;
        V               _max;
        std::string     _about;

      protected:
        std::list< KeyFrame<V> > _path;

    };


    class OpParDouble : public OpParameter<double>
    {
      public:
        OpParDouble( const std::string &name, const double& v ) : 
          OpParameter<double>( name, "double", v ) {};

        virtual int     fixMe( int fix_lvl=0 ) {};
        virtual void    setParameter( const PropertyNode * p );
        virtual double  getValue( Time t = 0 ) const;
        
    };

    class OpParString : public OpParameter<std::string>
    {
      public:
        OpParString( const std::string &name, const std::string& v ) : 
          OpParameter<std::string>( name, "string", v ) {};

        virtual int     fixMe( int fix_lvl=0 ) {};
        virtual void    setParameter( const PropertyNode * p );
        virtual std::string  getValue( Time t = 0 ) const;
        
    };

   class OpParColor : public OpParameter<Color>
   {
      public:
       OpParColor( const std::string &name, const Color& v ) : 
         OpParameter<Color>( name, "color", v ) {};

        virtual int     fixMe( int fix_lvl=0 ) {};
        virtual void    setParameter( const PropertyNode * p );
        virtual Color   getValue( Time t = 0 ) const;
        
    };

   class OpParBox : public OpParameter<Box>
    {
      public:
        OpParBox( const std::string &name, const Box& v ) : 
          OpParameter<Box>( name, "box", v ) {};

        virtual int     fixMe( int fix_lvl=0 ) {};
        virtual void    setParameter( const PropertyNode * p );
        virtual Box  getValue( Time t = 0 ) const;
        
    };



    /*
     *  \class Operator
     *
     */
    class Operator : public StoryElement, public PluginBase
    {
      public:
        Operator( const std::string & name ) :
          StoryElement( name ),
          PluginBase( )
            {};

        virtual ~Operator() {}

        void addParameter( OpParameterBase * v ) { _parameter.push_back( v ); };
        virtual void setParameter( const PropertyNode * p );

      private:
        std::list< OpParameterBase* > _parameter;
    };

    class UnaryOp : public Operator
    {
      public:
        UnaryOp( const std::string & name) : 
          Operator( name )
            {};

        virtual void renderFrame( Frame & f, Time t ) = 0;
    };
    

    class BinaryOp : public Operator
    {
      public:
        BinaryOp( const std::string & name) : 
          Operator( name )
            {};
        virtual void renderFrame( Frame & dest, Frame & src_a, 
                                  Frame & src_b, Time t ) = 0;
    };
  

    class NullUOp : public UnaryOp
    {
      public:
        NullUOp() : UnaryOp( "NullUOp" ) {};
        virtual void renderFrame( Frame & src, Time t ) {};
        virtual int  fixMe( int fix_lvl=0 ) { return 0; }
        virtual PropertyNode * getProperties( PropertyNode * p=0 ) const { return 0; };
    };



    class NullBOp : public BinaryOp
    {
      public:
        NullBOp() : BinaryOp( "NullBOp" ) {};
        virtual void renderFrame( Frame & dest, Frame & src_a, Frame & src_b, Time t ) {};
        virtual int  fixMe( int fix_lvl=0 ) { return 0; }
        virtual PropertyNode * getProperties( PropertyNode * p=0 ) const { return 0; };
    };
  

    class CopyAOp : public BinaryOp
    {
      public:
        CopyAOp() : BinaryOp( "CopyAOp" ) {};
        virtual void renderFrame( Frame & dest, Frame & src_a, Frame & src_b, Time t ) 
            { dest = src_a; };
        virtual int  fixMe( int fix_lvl=0 ) { return 0; }
        virtual PropertyNode * getProperties( PropertyNode * p=0 ) const { return 0; };
    };


    class ReplaceAudioOp : public BinaryOp
    {
      public:
        ReplaceAudioOp() : BinaryOp( "ReplaceAudioOp" ) {};
        virtual void renderFrame( Frame & dest, Frame & src_a, Frame & src_b, Time t );
        virtual int  fixMe( int fix_lvl=0 ) { return 0; }
        virtual PropertyNode * getProperties( PropertyNode * p=0 ) const { return 0; };
    };

    /**********************************************************************************
     *
     *
     *
     *   Template mamber function implementations
     *
     *
     *
     **********************************************************************************/
    
    template<class V>
    bool
    OpParameter<V>::removeKeyFrame( Time t )
    {
        iterator i = std::find( pbegin(), pend(), t );
        if ( i == pend() ) {
            WARN( "couldn't erase, no value at "<<PRINTV(t) );
            return false;
        }
        if ( i== pbegin() ) {
            WARN( "cannot erase first value" );
            return false;
        }
            
        _path.erase( i );

        return true;
    }

    template<class V>
    KeyFrame<V> *
    OpParameter<V>::makeNewKeyFrame( Time t, const V &v )
    {
        iterator i  = std::find( pbegin(), pend(), t );
        if ( i != pend() ) {
            INFO( "returning existing KeyFrame" );
            i->value = v;
            return &*i;
        }
        return &*_path.insert( std::lower_bound( pbegin(), pend(), t ), 
                               KeyFrame<V>( t, v ) );
    }

    template<class V>
    KeyFrame<V> *
    OpParameter<V>::getKeyFrame( Time t )
    {
        iterator i  = std::find( pbegin(), pend(), t );
        if ( i == pend() ) return 0;
        return &*i;
    }

//     int    
//     <V>::fixMe( int fix_lvl )
//     {
//         ABORT_IF ( _path.empty(), "no properties is path" );
//         int unfixed = 0;
        
//         if ( pbegin()->pos != 0 ) {
//             if ( fix_lvl>0 ) {
//                 WARN( "first prop is not at pos 0!" );
//                 pbegin()->pos = 0;
//             } else {
//                 unfixed++;
//             }
//         }

//         _path.unique();
//         _path.sort();

//         return unfixed;
//     }

};


#endif

---