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