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"

namespace Blink {

class BlinkRefHolder {
public:
  BlinkRefHolder();

  BlinkRefHolder(BlinkRef ref, bool retain);
  BlinkRefHolder(const BlinkRefHolder& holder);

  BlinkRefHolder& operator=(const BlinkRefHolder& holder);
  void take(BlinkRef ref);
  
  BlinkRefHolder& operator=(BlinkRef ref); 

  BlinkRef ref() const;

  ~BlinkRefHolder();

protected:
  BlinkRef _ref;
};


class ComputeDevice : protected BlinkRefHolder {
public:

  static ComputeDevice CurrentCPUDevice(); 

  static ComputeDevice CurrentGPUDevice();

  bool available() const; 

  std::string name() const; 

private:
  ComputeDevice(BlinkRef deviceRef);

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

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


class  Image : protected BlinkRefHolder {
public:

  Image(); 

  Image(const Image& src);


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

  Image& operator =(const Image&src); 

  Image distributeTo(const ComputeDevice& dev);

  Image makeLike(const ComputeDevice& dev);

  void copyFrom(const Image& src);

  BlinkImageInfo info() const; 

  void clear(); 

  bool isEmpty() const; 

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

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

  Image(BlinkRef ref);

  private:

  friend class Kernel;
  friend Image BlinkImageForBlinkRef(BlinkRef);
};

class ProgramSource : protected BlinkRefHolder {
public:
  ProgramSource(const char* source);
  ProgramSource(const std::string& source);

private:
  void setSource(const char* source);
  friend class Kernel;
};

class Kernel : protected BlinkRefHolder {

public:
  Kernel(const ProgramSource& programSource, ComputeDevice& dev, const std::vector<Image>& images, BlinkCodegenFlags 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 BlinkKernelIterationController& controller);
};

struct BufferDesc : BlinkBufferDesc {

  BufferDesc(unsigned int pixelStepBytes,
             unsigned int rowStepBytes,
             unsigned int componentStepBytes)
  {
    this->pixelStepBytes = pixelStepBytes;
    this->rowStepBytes = rowStepBytes;
    this->componentStepBytes = componentStepBytes;
  }
};

struct Rect : BlinkRect {

  Rect(int x1, int y1, int x2, int y2)
  {
    this->x1 = x1;
    this->y1 = y1;
    this->x2 = x2;
    this->y2 = y2;
  }
};

struct PixelInfo : BlinkPixelInfo {

  PixelInfo(int nComponents, BlinkDataType dataType)
  {
    this->nComponents = nComponents;
    this->dataType = dataType;
  }
};

struct ImageInfo : BlinkImageInfo {

  ImageInfo(const BlinkRect& bounds, const BlinkPixelInfo& pixelInfo)
  {
    this->bounds = bounds;
    this->pixelInfo = pixelInfo;
  }
};

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

protected:
  Exception(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};

class OutOfMemoryException : public Exception
{
protected:
  OutOfMemoryException(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};


class ComputeException : public Exception
{
protected:
  ComputeException(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};

class ImageSpecException : public Exception
{
protected:
  ImageSpecException(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};


class CompilationException : public Exception
{
protected:
  CompilationException(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};

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

  std::string parseError() const;
protected:
  ParseException(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};

class DeviceException : public Exception
{
protected:
  DeviceException(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};

class ParameterException: public Exception
{
protected:
  ParameterException(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};

class IncompatibleImagesException : public Exception
{
protected:
  IncompatibleImagesException(BlinkRef ref);
  friend void TranslateBlinkError(BlinkErrorCode errorCode, BlinkErrorRef errorRef);
};

}
#include "BlinkImpl.h"
#endif