Blink.h

Go to the documentation of this file.

// Copyright (c) 2013 The Foundry Visionmongers Ltd.  All Rights Reserved.

#ifndef Blink_Library_Blink_h
#define Blink_Library_Blink_h

#include "BlinkBuild.h"
#include <string>
#include <vector>

#include "BlinkTypes.h"
#include "BlinkConstants.h"
#include "BlinkVersion.h"

namespace Blink {

typedef BlinkComputeDeviceID ComputeDeviceID;
typedef BlinkCodegenFlags CodegenFlags;
typedef BlinkDataType DataType;
typedef BlinkRef Ref;
typedef BlinkErrorCode ErrorCode;
typedef BlinkErrorRef ErrorRef;
typedef BlinkMemoryType MemoryType;

typedef BlinkKernelType KernelType;
typedef BlinkKernelGranularity KernelGranularity;
typedef BlinkImageAccessType ImageAccessType;
typedef BlinkImagePatternType ImagePatternType;
typedef BlinkImageEdgeType ImageEdgeType;

struct DeviceMemory : BlinkDeviceMemory {
  DeviceMemory() {}
  DeviceMemory(const DeviceMemory& memory);
  DeviceMemory(MemoryType type, void* memoryBasePtr, unsigned long long memoryBaseSize, unsigned long long offset);
};

class RefHolder {
public:
  RefHolder();

  RefHolder(Ref ref, bool retain);
  RefHolder(const RefHolder& holder);

  RefHolder& operator=(const RefHolder& holder);
  void take(Ref ref);
  
  RefHolder& operator=(Ref ref);

  Ref ref() const;

  ~RefHolder();

protected:
  Ref _ref;
};


class ComputeDevice : protected RefHolder {
public:

  ComputeDevice(const ComputeDevice& dev);

  static ComputeDevice CurrentCPUDevice(); 

  static ComputeDevice CurrentGPUDevice();

  static ComputeDevice DeviceWithID(ComputeDeviceID id);

  bool available() const; 

  std::string name() const; 

private:
  ComputeDevice(Ref deviceRef);

  friend class ComputeDeviceBinder;
  friend class Image;
  friend class Kernel;
};

class ComputeDeviceBinder : protected RefHolder {
public:
  ComputeDeviceBinder(ComputeDevice& device);
};

class ProgramSource : protected RefHolder {
public:
  ProgramSource(const char* source);
  ProgramSource(const std::string& source);
  ProgramSource(const ProgramSource& foo);
private:
  void setSource(const char* source);
  friend class IKernel;
  friend class Kernel;
};

struct Rect : BlinkRect {

  Rect();

  Rect(const Rect& r);

  Rect(int x1, int y1, int x2, int y2);

  int width() const;
  int height() const;
};

struct KernelIterationController : BlinkKernelIterationController {

  KernelIterationController(const KernelIterationController& iterationController);
  KernelIterationController(const Rect& bounds);
};

struct BufferDesc : BlinkBufferDesc {

  BufferDesc();

  BufferDesc(unsigned int pixelStepBytes,
             unsigned int rowStepBytes,
             unsigned int componentStepBytes);
};

struct PixelInfo : BlinkPixelInfo {

  PixelInfo();
  PixelInfo(int nComponents, DataType dataType);
};

struct ImageInfo : BlinkImageInfo {

  ImageInfo();

  ImageInfo(const ImageInfo& info);

  ImageInfo(const Rect& bounds, const PixelInfo& pixelInfo);

  Rect bounds() const;
};

struct ImageAccessDesc : BlinkImageAccessDesc {
  ImageAccessDesc(void) {}
  ImageAccessDesc(BlinkImagePatternType type);
  ImageAccessDesc(BlinkAxisType axis, int min, int max);
  ImageAccessDesc(Rect Range);
};

class  Image : protected RefHolder {
public:

  Image();

  Image(const Image& src);


  Image(const ImageInfo& info, ComputeDevice& device);


  Image(const DeviceMemory& memory, const ImageInfo &info, const BufferDesc& desc, ComputeDevice &device);

  Image& operator =(const Image&src);

  Image distributeTo(const ComputeDevice& dev);

  Image makeLike(const ComputeDevice& dev);

  void copyFrom(const Image& src);

  ImageInfo info() const;

  void clear();

  bool isEmpty() const;

  void copyToBuffer(void* buffer, const BufferDesc& bufferDesc) const;

  void copyFromBuffer(const void* buffer, const BufferDesc& bufferDesc) const;

  Image(Ref ref);

  private:

  friend class Kernel;
  //friend Image BlinkImageForRef(Ref);
};

struct KernelInfo : BlinkKernelInfo {

  KernelInfo();

  KernelInfo(const KernelInfo& info);

  KernelInfo(const std::string& name, KernelType type,
             KernelGranularity granularity);

  std::string getName() const;
  KernelType getType() const;
  KernelGranularity getGranularity() const;
};

struct KernelImageInfo : BlinkKernelImageInfo {
  
  KernelImageInfo();
  
  KernelImageInfo(const KernelImageInfo& info);
  
  KernelImageInfo(const std::string& name, ImageAccessType accessType,
                  ImagePatternType patternType, ImageEdgeType edgeType);
  
  std::string getName() const;
  ImageAccessType getAccessType() const;
  ImagePatternType getPatternType() const;
  ImageEdgeType getEdgeType() const;
};

struct KernelParameterInfo : BlinkKernelParameterInfo {
  
  KernelParameterInfo();
  
  KernelParameterInfo(const KernelParameterInfo& info);
  
  KernelParameterInfo(const std::string& name, DataType type, unsigned nComponents,
                      unsigned nElements);
  
  unsigned getNumParameters();
  
  std::string getName() const;
  DataType getDataType() const;
  unsigned getNComponents() const;
  unsigned getNElements() const;
};

class IKernel : protected RefHolder {

public:
  IKernel(const ProgramSource& programSource);

  unsigned getNumImages() const;
  unsigned getNumParameters() const;

  KernelInfo getKernelInfo() const;
  
  std::vector<KernelImageInfo> getImagesInfo() const;
  
  std::vector<KernelParameterInfo> getParametersInfo() const;

protected:
  IKernel();
};

class Kernel : public IKernel {

public:
  Kernel(const ProgramSource& programSource, ComputeDevice& dev, const std::vector<Image>& images, CodegenFlags flags = kBlinkCodegenDefault);

  void setParamValue(const std::string& name, bool value);
  void setParamValue(const std::string& name, float value);
  void setParamValue(const std::string& name, int value);

  void setParamValue(const std::string& name, const char* value, unsigned int count);
  void setParamValue(const std::string& name, const float* value, unsigned int count);
  void setParamValue(const std::string& name, const int* value, unsigned int count);

  void getParamValue(const std::string& name, char* value, unsigned int count);
  void getParamValue(const std::string& name, float* value, unsigned int count);
  void getParamValue(const std::string& name, int* value, unsigned int count);

  std::vector<Blink::ImageAccessDesc> getInputRanges(void);

  //Iterate the kernel using the last image as the iteration bounds
  void iterate();

  //Iterate over the provided bounds
  void iterate(const KernelIterationController& controller);
};


class Exception : protected RefHolder
{
public:
  std::string userMessage() const;

protected:
  Exception(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};

class OutOfMemoryException : public Exception
{
protected:
  OutOfMemoryException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};


class ComputeException : public Exception
{
protected:
  ComputeException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};

class ImageSpecException : public Exception
{
protected:
  ImageSpecException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};


class CompilationException : public Exception
{
protected:
  CompilationException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};

class ParseException : public CompilationException
{
public:
  int lineNumber() const;

  std::string parseError() const;
protected:
  ParseException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};

class DeviceException : public Exception
{
protected:
  DeviceException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};

class ParameterException: public Exception
{
protected:
  ParameterException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};

class IncompatibleImagesException : public Exception
{
protected:
  IncompatibleImagesException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};

class InvalidAccessDescException : public Exception
{
protected:
  InvalidAccessDescException(Ref ref);
  friend void TranslateBlinkError(ErrorCode errorCode, ErrorRef errorRef);
};

}
#include "BlinkImpl.h"
#endif