---

/home/slang/XVision2/src/Pipes/PipeImage.h

# ifndef _PIPEIMAGE_H_
# define _PIPEIMAGE_H_

# include <config.h>
# include "PipeModules.h"
# include <Video.h>
# include <XVImageScalar.h>
# include <XVWindowX.h>

// Video source pipe class, basically a wrapper of Video class

template<class T>
class PipeVideoSource : public PipeLift0<XVImageRGB<T> > {
  typedef PipeVideoSource<T> ThisType ;
  typedef PipeLift0<ReturnType> BaseType ;

 protected:  
  Video<T> * v ;
  
  ThisType * duplicate(void) const { return new ThisType(*this); }
  inline void check(void) { PipeModule<ReturnType>::check( v ); }

 public:

  PipeVideoSource( Video<T>& vin ) : BaseType(), v(&vin) {}
  PipeVideoSource( const ThisType& p ) : BaseType(p), v(p.v) {}

  ReturnType compute_local_fn( int fc )
    {
      check();
      // Some checks should be done at this point to see if the source
      // is drained so as to throw out a BrokenPipe exception, but this
      // cannot achived without support from Video classes (i.e. a sepcial
      // return value from request_frame_continues()
      return v->next_frame_continuous();
    }

  operator ResultType () const { return ResultType(duplicate()) ; }

  ResultType operator () (void) const { return ResultType(duplicate()) ; }
};

// Video display class which is drawable
// This class doesn't work within PipeFun

class PipeShowable {
 public:
  virtual void show( int fc, XVDrawable& ) = 0 ;
};

template<class T>
class PipeShowableClass : public PipeShowable {
  T * t ;
 public:
  PipeShowableClass( T& obj ) : t(&obj) {}
  virtual void show( int fc, XVDrawable& d ) { t->show(d) ; }
};

template<class T>
class PipeShowablePipe : public PipeShowable {
  Pipe<T> * t ;
 public:
  PipeShowablePipe( const Pipe<T>& p ) : t( new Pipe<T>(p) ) {}
  virtual void show( int fc, XVDrawable& d ) { t->get_value(fc).show(d) ; }
};

template<class T>
class PipeDrawDisplay: public PipeLift1<XVImageRGB<T>, XVImageRGB<T> > {
  typedef PipeDrawDisplay<T> ThisType ;
  typedef PipeLift1<XVImageRGB<T>, XVImageRGB<T> > BaseType ;
 protected:
  struct ShowItem {
    PipeShowable * item ;
    ShowItem * next ;
    ShowItem( PipeShowable * i, ShowItem * n = 0 ) : item(i), next(n) {}
    ~ShowItem() { delete item ; delete next ; }
  } * head, ** tail ;

 protected:
  XVDrawWindowX<T> * w;
  Pipe<XVImageRGB<T> > *pred;

 protected:
  void setDependency(void) { addDependency((DependencyUnit**)&pred); }
  ThisType * duplicate(void) const { return new ThisType(*this); }
  inline void check(void) { PipeModule<XVImageRGB<T> >::check( pred ); }

public:
  PipeDrawDisplay() : head(0), tail(0), w(0), pred(0) 
    { tail = &head ; setDependency() ; }
  // memory leaks here: get it fixed when have time
  PipeDrawDisplay( const ThisType& p ) : BaseType(p), head(p.head), 
    tail(p.tail), w(p.w), pred(p.pred) { setDependency() ; }

  ResultType operator () ( const Pipe<XVImageRGB<T> >& x ) const
    {
      ThisType *p = duplicate();
      p->pred = new Pipe<XVImageRGB<T> >(x);
      return ResultType(p);
    }

  ReturnType compute_local_fn(int fc) 
    {
      check();
      ReturnType image = (*pred)->get_value(fc);
      if (!w) {
     w = new XVDrawWindowX<T>(&image) ;
     w->map();
     w->setCOPY();
      }
      w->CopySubImage(&image);
      for( ShowItem * p = head ; p != *tail ; p = p -> next ) {
     p->item->show(fc,*w) ;
      }
      w->swap_buffers();
      w->flush();
      return image;
    }

  ThisType& operator << ( PipeShowable* x ) 
    { 
      *tail = new ShowItem(x,*tail) ; 
      tail = &((*tail)->next) ; 
      return *this ; 
    }

  template<class D> 
  ThisType operator << ( const Pipe<D>& p ) 
    { return (*this) << new PipeShowablePipe<D>(p) ; }

  template<class D>
  ThisType operator << ( D& d )
    { return (*this) << new PipeShowableClass<D>(d) ; }
};

// Video display class that is not drawable, so basically useless

template<class T>
class PipeVideoDisplay: public PipeModule<XVImageRGB<T> > {
 protected:
  XVWindowX<T> * w;
  Pipe<XVImageRGB<T> > *pred;

 protected:
  
  inline void check(void) { PipeModule<XVImageRGB<T> >::check( pred ); }

public:
  PipeVideoDisplay() : w(0), pred(0) {}

  operator Pipe<T> () const 
    { return Pipe<XVImageRGB<T> >(new PipeVideoDisplay<T>(*this)) ; }

  Pipe<XVImageRGB<T> > operator () ( const Pipe<XVImageRGB<T> >& x ) const
    {
      PipeVideoDisplay *p = new PipeVideoDisplay<T>();
      p->pred = new Pipe<XVImageRGB<T> >(x);
      return Pipe<XVImageRGB<T> >(p);
    }

  XVImageRGB<T> compute_local_fn(int fc) 
    {
      check();
      XVImageRGB<XV_RGB> image = (*pred)->get_value(fc);
      if (!w) {
     w = new XVWindowX<T>(&image) ;
     w->map();
      }
      w->CopySubImage(&image);
      w->swap_buffers();
      w->flush();
      return image;
    }
};

// Shorthands for pure image lifts

template<class Tout, class Tin>
class ScalarImageLift1 {
 public:
  typedef PipeModuleLift1< XVImageScalar<Tout>, XVImageScalar<Tin>, 
    XVImageScalar<Tout> (*)(const XVImageScalar<Tin>&)> Type ;
};

template<class Tout, class Tin1, class Tin2>
class ScalarImageLift2 { 
 public:
  typedef PipeModuleLift2< XVImageScalar<Tout>, XVImageScalar<Tin1>, 
    XVImageScalar<Tin2>, XVImageScalar<Tout> (*)
    (const XVImageScalar<Tin1>&,const XVImageScalar<Tin1>&)> Type ;
};

// Lifted operators

//extern ScalarImageLift1<int,int>::Type Prewitt_xP;
//extern ScalarImageLift1<int,int>::Type Prewitt_yP;
extern PipeModuleLift2Types<XVImageScalar<int>, XVImageScalar<int>, 
                            XVImageGeneric>::Ref SubImageG;
extern PipeModuleLift3Types<XVImageScalar<int>, XVImageScalar<int>, 
                            XVSize, XVPosition>::Ref SubImageSP;


# endif //_PIPEIMAGE_H_

---