MeVis/Foundation/Sources/ML/include/host/mlTileRequest.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#ifndef __mlTileRequest_H
#define __mlTileRequest_H

// ML-includes
#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif

#include "mlSubImage.h"
#include "mlPagedImage.h"
#include "mlPageIDIterator.h"

ML_START_NAMESPACE

class TileRequest;
class PageRequest;
class PageRequestQueueInterface;

typedef void TileRequestFinishedCB(void* data, TileRequest* request);

//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
class ML_UNIX_ONLY_EXPORT(MLEXPORT) TileRequest
{

public:
  static TileRequest* allocate();

  static void deallocate(TileRequest* request);

  static void clearFreeList();

private:
  TileRequest();

  void cleanup();

  TileRequest* _freeListNext;

  static TileRequest* _freeListHead;
  static Mutex        _freeListMutex;

public:

  void init(PagedImage* inputImage, const SubImageBox& box, MLDataType dataType,
              const ScaleShiftData& scaleShift, bool readOnlyInputTile = false, bool tryToBecomeMemoryImage = false);

  enum AllocationPolicy {
    UseMemoryManager = 0,  //<! This will allocate the memory using the MemoryManager
    UseMLAlloc       = 1,  //<! This will allocate the memory using MLAlloc
    NoAllocation     = 2,  //<! This can be used if no data should be allocated at all (e.g., for processAllPages)
    ExternalBuffer   = 3   //<! This can be used to provide the data by the user (and to avoid freeing the data when something goes wrong)
  };

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

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

  bool prepareForCursorVisit();

  void  createInputPageIds();

  void  setNeededBy(PageRequest* request) {
    _neededByPageRequest = request;
  }

  bool  isBlockedByMemoryImage();

  void pageRequestFinished(SubImage& pageImage, PageRequestQueueInterface& queue);


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

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

  void setAllocationPolicy(AllocationPolicy policy) { _allocationPolicy = policy; }

  AllocationPolicy getAllocationPolicy() const { return _allocationPolicy; }

  void allocateData();

  void  forgetData() { _subImage.setData(NULL); }

  void  freeData() { if (_allocationPolicy!=ExternalBuffer) { _subImage.free(); } }

  const SubImage& getSubImage() const { return _subImage; }

  void setExternalDataBuffer(void* data) {
    setAllocationPolicy(TileRequest::ExternalBuffer);
    _subImage.setData(data);
  }

  void setUseTileReadOnly(bool flag) { _readOnlyInputTile = flag; }


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

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

  bool hasFinished() const;

  void setTileRequestFinishedCB(TileRequestFinishedCB* cb, void* data) {
    _finishedCB = cb;
    _finishedCBData = data;
  }

  void setInternalTileRequestFinishedCB(TileRequestFinishedCB* cb, void* data) {
    _internalFinishedCB = cb;
    _internalFinishedCBData = data;
  }

  double getProgress() const;


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

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

  bool hasError() const { return _error!=ML_RESULT_OK; }

  void setError(MLErrorCode error);

  MLErrorCode getError() const { return _error; }

  void propagateErrorUpwards(MLErrorCode error);

  bool propagateCancellationDownIfRequestNotNeededAnymore();

  void collectPageRequestsWithErrors(std::set<PageRequest*>& result);


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

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

  MLErrorCode updateImageProperties();

  int getProcessingScope() const  { return _processingScope; }

  void setProcessingScope(int scope) { _processingScope = scope; }

  const SubImageBox& getBox() const  { return _subImage.getBox(); }

  bool  intersectsPagedImage() const;

  void  updateSourceImageExtent();


protected:
  friend class PageRequestCursor;

  PageRequest* createPageRequest(MLint pageId, PageRequestQueueInterface& queue);

  bool         copyDataFromSubImg(SubImage& pageImage);

  void         sendTileRequestFinished(PageRequestQueueInterface& queue);

  void emitFinishedCallback();

  SubImage _subImage;

  AllocationPolicy _allocationPolicy;

  ScaleShiftData _scaleShiftData;

  bool           _readOnlyInputTile;
  bool           _tileWillBecomeMemoryImage;

  PagedImage*  _image;

  MLint      _inputPagesNeeded;

  Mutex      _inputPagesNeededMutex;

  PageIDIterator _inputPageIds;

  MLint          _traversalCursorPosition;

  PageRequest*   _neededByPageRequest;

  MLErrorCode    _error;

  int _processingScope;

  TileRequestFinishedCB* _finishedCB;
  void*                  _finishedCBData;

  TileRequestFinishedCB* _internalFinishedCB;
  void*                  _internalFinishedCBData;

public:
  static void enableAllocationFailure(int count = 1);
  static void disableAllocationFailure() { _forceAllocationFailure = false; }

private:
  static bool _forceAllocationFailure;
  static int  _forceAllocationFailureCount;
  static int  _forceAllocationFailureModulo;

};

ML_END_NAMESPACE

#endif //of __mlTileRequest_H