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;

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);

private:
  void setSource(const char* source);
  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;
};

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);
};



class Kernel : protected RefHolder {

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, float* value, unsigned int count);
  void getParamValue(const std::string& name, int* value, unsigned int count);

  //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);
};

}
#include "BlinkImpl.h"
#endif