mlTileRequest.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2009, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_TILE_REQUEST_H
#define ML_TILE_REQUEST_H

 
// ML-includes
#include "mlInitSystemML.h"
 
#include "mlSubImage.h"
#include "mlPagedImage.h"
#include "mlPageIDIterator.h"
 
#include <set>
 
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 if 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(nullptr); }

  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