lib/processthread.h

#ifndef __PROCESSTHREAD_H__
#define __PROCESSTHREAD_H__

#include <stdint.h>

#include <map>
#include <set>
#include <utility>
#include <string>

#include "stm_export.h"
#include "threadutils.h"
#include "scheduler.h"
#include "modules.h"

// Forward declarations
namespace spectral
{
    class Processor;
    class Image;
    class Parameters;
}

// Class definitions
namespace control 
{

class STM_EXPORT Message
{
public:
    enum Type
    {
        // Control
        MSG_START,          // Start processing.
        MSG_STOP,           // Stop processing.
        MSG_SHUTDOWN,       // Terminate thread.
        MSG_EXIT,           // Terminate app.

        // graph setup
        MSG_SET_ACTOR,      // set a processor actor
        MSG_SET_INPUT,      // Set an input.
        // Input
        MSG_PARAMETERS,     // Set parameters
        MSG_SET_IMAGE,      // Set an image.
        MSG_LOAD_IMAGE,     // Load an image.
        MSG_SAVE_IMAGE,     // Save an image.
        // MSG_Status
        MSG_IMAGE_LOAD_SUCCEEDED,   // Successful load
        MSG_IMAGE_LOAD_FAILED,      // Unsuccessful load
        MSG_PROGRESS,       // Report progress
        MSG_ERROR,          // Report an error
        MSG_STARTED,        // Begin working.
        MSG_STOPPED,        // Finish working.
        MSG_RESULT,         // Pass a result.
        // notifications.
        MSG_ACTOR_INSTALLED,
        MSG_ACTOR_REMOVED,
        MSG_INPUT_ADDED,
        MSG_INPUT_REMOVED,
        // info requests
        MSG_REQUEST_PARAMETERS, // Get parameters.
        MSG_REQUEST_IMAGE, // Get parameters.
        // MSG_Final
        MSG_MAX
    };
    Message(Type type)
        : m_type(type)
        , m_id(0)
        , m_floatData(0)
        , m_image(NULL)
        , m_parameters(NULL)
        , m_link(0,0)
    {
    }
    Message(Type type,
            int id)
        : m_type(type)
        , m_id(id)
        , m_floatData(0)
        , m_image(NULL)
        , m_parameters(NULL)
        , m_link(0,0)
    {
    }
    Message(Type type,
            int id,
            float    floatData)
        : m_type(type)
        , m_id(id)
        , m_floatData(floatData)
        , m_image(NULL)
        , m_parameters(NULL)
        , m_link(0,0)
    {
    }
    Message(Type type,
            int id,
            spectral::Image *image)
        : m_type(type)
        , m_id(id)
        , m_floatData(0)
        , m_image(image)
        , m_parameters(NULL)
        , m_link(0,0)
    {
    }
    Message(Type type,
            int id,
            spectral::Parameters *params)
        : m_type(type)
        , m_id(id)
        , m_floatData(0)
        , m_image(NULL)
        , m_parameters(params)
        , m_link(0,0)
    {
    }
    Message(Type type,
            int id,
            std::string string)
        : m_type(type)
        , m_id(id)
        , m_floatData(0)
        , m_image(NULL)
        , m_parameters(NULL)
        , m_string(string)
        , m_link(0,0)
    {
    }
    Message(Type type,
            int id,
            std::pair<uint32_t, int32_t> link)
        : m_type(type)
        , m_id(id)
        , m_floatData(0)
        , m_image(NULL)
        , m_parameters(NULL)
        , m_link(link)
    {
    }

    ~Message(){};

    Type GetType()                        {return m_type;}
    int GetId()                           {return m_id;}
    float    GetFloat()                   {return m_floatData;}
    spectral::Image *GetImage()           {return m_image;}
    spectral::Parameters *GetParameters() {return m_parameters;}
    std::string GetString()               {return m_string;}
    std::pair<uint32_t, int32_t> GetLink(){return m_link;}
private:
    Type                         m_type;
    int                          m_id;
    float                        m_floatData;
    spectral::Image             *m_image;
    spectral::Parameters        *m_parameters;
    std::string                  m_string;
    std::pair<uint32_t, int32_t> m_link;
};

class STM_EXPORT MessageQueue : public thread::Fifo<Message>
{
};

// Wraps a processor object.
class STM_EXPORT ProcessThread : public thread::Thread
{
public:
    ProcessThread(int id,
                  spectral::Processor *processor,
                  MessageQueue &output);
    virtual ~ProcessThread();


    void Process(void);
    void Shutdown(void);

    void SetImage(int, spectral::Image *);
    void SetParameters(spectral::Parameters *);

    // Send progress message to output queue.
    void Progress(float);

protected:
    virtual void *MainLoop(void);
private:

    MessageQueue          &m_outputQueue;
    MessageQueue           m_inputQueue;
    spectral::Processor   *m_processor;
    bool                   m_active;
    int                    m_id;
};

}

#endif

---