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

} // namespace Blink
#include "BlinkImpl.h"
#endif