MeVis/Foundation/Sources/MLBackgroundTasks/mlImagingBackgroundTask.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------


#ifndef __mlImagingBackgroundTask_H
#define __mlImagingBackgroundTask_H


// Local includes
#include "MLBackgroundTasksSystem.h"

#include "mlMessagingBackgroundTask.h"
#include "mlManagedSubImage.h"
#include "mlTimeCounter.h"
#include "host/mlTileRequest.h"

ML_START_NAMESPACE

//-----------------------------------------------------------------------

typedef MLuint32 BackgroundRequestId;

class MLBACKGROUNDTASKS_EXPORT ImagingBackgroundTask : public MessagingBackgroundTask
{
  ML_DISALLOW_COPY_AND_ASSIGN(ImagingBackgroundTask)

public:

  ImagingBackgroundTask(void* owner);
  virtual ~ImagingBackgroundTask();

  enum TileRequestFlags {
    UseMemoryManager = TileRequest::UseMemoryManager,  //<! This will allocate the memory using the MemoryManager
    UseMLAlloc       = TileRequest::UseMLAlloc,        //<! This will allocate the memory using MLAlloc
    NoAllocation     = TileRequest::NoAllocation,      //<! This can be used if no data should be allocated at all (e.g. for processAllPages)
    ExternalBuffer   = TileRequest::ExternalBuffer,    //<! This can be used to provide the data by the user
    AllocationPolicyMask = 0xf,                        //<! Mask to get a AsyncTileRequest ::AllocationPolicy enum from the flags value.

    RequestReadOnlyPage     = 16,                      //<! Request the data of the AsyncTileRequest  as read-only page data, this requires that the given box
                                                       //<! matches a page's box, datatype and that scale/shift has the default value. This override the
                                                       //<! allocation policy above.
    ReceiveProgressMessages = 32                       //<! Receive progress messages for the AsyncTileRequest .
  };

  class AsyncTileRequest  {
  public:
    AsyncTileRequest ():_tileId(0),_task(NULL) {};
    AsyncTileRequest (BackgroundRequestId tileId, ImagingBackgroundTask* task)
      : _tileId(tileId), _task(task)
    {}

    ManagedSubImage* getTile() {
      bool found;
      return _task->getFinishedRequest(_tileId, found);
    };

  private:
    BackgroundRequestId   _tileId;
    ImagingBackgroundTask* _task;
  };


  class ProcessAllPagesRequest {
  public:
    ProcessAllPagesRequest():_id(0),_task(NULL) {};
    ProcessAllPagesRequest(BackgroundRequestId tileId, ImagingBackgroundTask* task)
      : _id(tileId), _task(task)
    {}

    bool waitUntilFinished() {
      return _task->waitForProcessAllPages(_id);
    }

  private:
    BackgroundRequestId _id;
    ImagingBackgroundTask* _task;
  };

protected:
  BackgroundRequestId generateBackgroundRequestId() {
    return _nextTileRequestId++;
  }

private:
  friend class  BackgroundTaskMLGetTileResultMessage;
  friend class  BackgroundTaskMLProcessAllPagesResultMessage;
  friend class  AsyncTileRequest ;
  friend class  ProcessAllPagesRequest;

  struct RequestResult
  {
    RequestResult(BackgroundRequestId id, ProcessAllPagesHandler* handler) {
      this->id = id;
      this->handler = handler;
      this->image = NULL;
    }

    RequestResult(BackgroundRequestId id, ManagedSubImage* image) {
      this->id = id;
      this->image = image;
      this->handler = NULL;
    }

    void free() {
      ML_DELETE(image);
      ML_DELETE(handler);
    }

    // public access to variables
    BackgroundRequestId     id;
    ProcessAllPagesHandler* handler;
    ManagedSubImage*        image;
  };

  ManagedSubImage* takeRequestIfAvailable(BackgroundRequestId tileId, bool& found);

  ManagedSubImage* getFinishedRequest(BackgroundRequestId tileId, bool& found);

  bool             waitForProcessAllPages(BackgroundRequestId id);

  void addFinishedRequest(BackgroundRequestId tileId, ManagedSubImage* image);

  void addFinishedRequest(BackgroundRequestId tileId, ProcessAllPagesHandler* handler);

  std::deque<RequestResult> _availableTiles;
  BackgroundRequestId _nextTileRequestId;

};


ML_END_NAMESPACE

#endif