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 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(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