/home/rex/ebltrunk/tools/libeblearntools/include/fprop_thread.h

/***************************************************************************
 *   Copyright (C) 2011 by Pierre Sermanet *
 *   pierre.sermanet@gmail.com *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef FPROP_THREAD_H_
#define FPROP_THREAD_H_

#include <stdio.h>
#include <stdlib.h>

#include "defines_tools.h"
#include "thread.h"
#include "netconf.h"
#include "configuration.h"

using namespace std;

namespace ebl {

// switch between forward only buffers or also backward
#define FPROP_SFUNC fs
#define FPROP_SBUF fstate_idx
#define SFUNC2(T) T,T,T,SBUF<T>
#define SFUNC3(T) T,SBUF<T>,mstate<SBUF<T> >
// backward
// #define FPROP_SFUNC bbs
// #define SBUF bbstate_idx
  
  // A detection thread class

  template <typename Tnet>
  class fprop_thread : public thread {
  public:
    fprop_thread(configuration &conf, mutex *om = NULL,
                     const char *name = "",
                     const char *arg2 = NULL, bool sync = true,
                     t_chans tc = CHANS_RGB);
    ~fprop_thread();
    
    virtual void execute();
    virtual bool set_data(idx<ubyte> &frame, string &frame_name, uint frame_id);
    virtual bool get_data(idx<ubyte> &frame, string &frame_name,
                          uint &frame_id);
    virtual bool set_dump(string &frame_fname, string &dump_fname);
    virtual bool dumped();
    virtual bool available();
    virtual void set_output_directory(string &out);
    
  private:
    void set_out_updated();

    // private members
  private:
    configuration                conf;
    const char                  *arg2;
    idx<ubyte>                   uframe;
    idx<Tnet>                    frame;
    mutex                        mutex_in;      // mutex for thread input
    mutex                        mutex_out;     // mutex for thread output
    bool                         in_updated;    // thread input updated
    bool                         out_updated;   // thread output updated
    bool                         bavailable;    // thread is available
    string                       frame_name;    // name of current frame
    uint                         frame_id;      
    string                       outdir;        // output directory
    using thread::mout; 
    using thread::merr; 
    t_chans                      color_space;
    bool                         bload_image;    

  public:
    detector<FPROP_SFUNC(Tnet)>       *pdetect;
  };

} // end namespace ebl

#include "fprop_thread.hpp"

#endif /* FPROP_THREAD_H_ */