ndspy.h

Go to the documentation of this file.

/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 2020 Pixar. All rights reserved.
#
# The information in this file (the "Software") is provided for the exclusive
# use of the software licensees of Pixar ("Licensees").  Licensees have the
# right to incorporate the Software into other products for use by other
# authorized software licensees of Pixar, without fee. Except as expressly
# permitted herein, the Software may not be disclosed to third parties, copied
# or duplicated in any form, in whole or in part, without the prior written
# permission of Pixar.
#
# The copyright notices in the Software and this entire statement, including the
# above license grant, this restriction and the following disclaimer, must be
# included in all copies of the Software, in whole or in part, and all permitted
# derivative works of the Software, unless such copies or derivative works are
# solely in the form of machine-executable object code generated by a source
# language processor.
#
# PIXAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL PIXAR BE
# LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  IN NO CASE WILL
# PIXAR'S TOTAL LIABILITY FOR ALL DAMAGES ARISING OUT OF OR IN CONNECTION WITH
# THE USE OR PERFORMANCE OF THIS SOFTWARE EXCEED $50.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/

#ifndef NDSPY_H
#define NDSPY_H

#include <math.h>      // for floorf
#include "prmanapi.h"  // for PRMANAPI, PRMANEXPORT
#include "ri.h"        // for RtPointer

// 2^17 - 8. This makes the dsyp server channel buffer large enough to send
// float RGBA 64x64 buckets without splitting them vertically.
#define PkDspyMaxMsgSize 131064

#define PkDspyServerMsgOpen (65 + 1)
#define PkDspyServerMsgImage (65 + 2)
#define PkDspyServerMsgData (65 + 3)
#define PkDspyServerMsgQuery (65 + 4)
#define PkDspyServerMsgClose (65 + 5)
#define PkDspyServerMsgDeepData (65 + 6)
#define PkDspyServerMsgActiveRegion (65 + 7)
#define PkDspyServerMsgMetadata (65 + 8)
#define PkDspyServerMsgMetadataPart (65 + 9)

/*
PtDspyUnsigned64
PtDspySigned64
*/
typedef double PtDspyFloat64;
typedef float PtDspyFloat32;

#if defined(__mips)
#define PkDspyByteOrderNative PkDspyByteOrderHiLo
#elif defined(__mips64)
#define PkDspyByteOrderNative PkDspyByteOrderHiLo
#elif defined(__sparc)
#define PkDspyByteOrderNative PkDspyByteOrderHiLo
#elif defined(__alpha)
#define PkDspyByteOrderNative PkDspyByteOrderLoHi
#elif defined(__ppc__)
#define PkDspyByteOrderNative PkDspyByteOrderHiLo
#else
#define PkDspyByteOrderNative PkDspyByteOrderLoHi
#endif

typedef unsigned int PtDspyUnsigned32;
typedef int PtDspySigned32;

typedef unsigned short PtDspyUnsigned16;
typedef short PtDspySigned16;

typedef unsigned char PtDspyUnsigned8;
typedef char PtDspySigned8;

typedef PtDspyUnsigned32 PtDspyMsgLen;
typedef PtDspyUnsigned32 PtDspyServerMessage;

#define PkDspyClassFloat 1
#define PkDspyClassInt 2

#define PkDspyNone 0
#define PkDspyFloat32 1
#define PkDspyUnsigned32 2
#define PkDspySigned32 3
#define PkDspyUnsigned16 4
#define PkDspySigned16 5
#define PkDspyUnsigned8 6
#define PkDspySigned8 7
#define PkDspyArrayBegin 10
#define PkDspyArrayEnd 11

#define PkDspyMaskType 8191

#define PkDspyMaskOrder (PkDspyByteOrderHiLo | PkDspyByteOrderLoHi)
#define PkDspyShiftOrder 13
#define PkDspyByteOrderHiLo 8192
#define PkDspyByteOrderLoHi 16384

/*
 * PkDspyOpenPortCount controls the number of open display connections are used
 * by netrender/windows - or any process with an "internal" display server.
 */
#define PkDspyOpenPortCount 1024

typedef struct
{
    char const* name;
    unsigned type;
} PtDspyDevFormat;

typedef struct
{
    PtDspyUnsigned32 width;
    PtDspyUnsigned32 height;
    PtDspyFloat32 aspectRatio;
} PtDspySizeInfo;

typedef struct
{
    PtDspyUnsigned8 overwrite;
    PtDspyUnsigned8 interactive;
} PtDspyOverwriteInfo;
typedef struct
{
    PtDspyUnsigned8 redraw;
} PtDspyRedrawInfo;

typedef struct
{
    PtDspyUnsigned8 rewrite;
} PtDspyRewriteInfo;

typedef struct
{
    PtDspySigned32 xmin;
    PtDspySigned32 xmax;
    PtDspySigned32 ymin;
    PtDspySigned32 ymax;
} PtDspyNextDataInfo;

typedef struct
{
    PtDspyUnsigned32 x;
    PtDspyUnsigned32 y;
} PtDspyRenderingStartQuery;

typedef struct
{
    int canCheckpoint;
} PtDspySupportsCheckpointing;

typedef struct
{
    int supportsPointClouds;
} PtDspyPointCloudQuery;

typedef struct
{
    int supportsGrids;
} PtDspyGridQuery;

typedef struct
{
    int supportsMultiResolution;
} PtDspyMultiResolutionQuery;

typedef struct
{
    int zero, one, min, max;
    float ditheramplitude;
    int driverWantsToQuantize;
} PtDspyQuantizationQuery;

typedef struct
{
    PtDspyUnsigned32 peakkB, currentkB;
} PtMemoryUsageQuery;

typedef struct
{
    PtDspyUnsigned32 seconds;
} PtElapsedTimeQuery;

typedef enum
{
    PkSizeQuery,
    PkOverwriteQuery,
    PkNextDataQuery,
    PkRedrawQuery,
    PkRenderingStartQuery,
    PkSupportsCheckpointing,
    PkPointCloudQuery,
    PkGridQuery,
    PkMultiResolutionQuery,
    PkQuantizationQuery,
    PkMemoryUsageQuery,
    PkElapsedTimeQuery,
} PtDspyQueryType;

typedef enum
{
    PkDspyGridConnected,
    PkDspyGridLines,
    PkDspyGridPoints
} PtDspyGridStyle;

typedef enum
{
    PkDspyBucketOrderHorizontal = 1,
    PkDspyBucketOrderVertical,
    PkDspyBucketOrderZigZagX,
    PkDspyBucketOrderZigZagY,
    PkDspyBucketOrderSpiral,
    PkDspyBucketOrderSpaceFill,
    PkDspyBucketOrderRandom
} PtDspyBucketOrder;

typedef enum
{
    PkDspyErrorNone = 0,
    PkDspyErrorNoMemory,
    PkDspyErrorUnsupported,
    PkDspyErrorBadParams,
    PkDspyErrorNoResource,
    PkDspyErrorUndefined,
    PkDspyErrorCancel
} PtDspyError;

#define PkDspyFlagsWantsScanLineOrder 1
#define PkDspyFlagsWantsEmptyBuckets 2
#define PkDspyFlagsWantsNullEmptyBuckets 4
typedef struct
{
    int flags;
} PtFlagStuff;

typedef void* PtDspyImageHandle;

typedef void* PtDspyChannel;

typedef void* PtDspyOutput;

typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
    PtDspyUnsigned32 width;
    PtDspyUnsigned32 height;
    PtDspyUnsigned32 formatCount;
} PtDspyMsgOpen;
typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
    PtDspyUnsigned32 width;
    PtDspyUnsigned32 height;
    PtDspyUnsigned32 formatCount;
    PtDspyUnsigned32 paramCount;
} PtDspyMsgAddOutput;

typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
    PtDspyUnsigned32 formatCount;
    PtDspyUnsigned32 paramCount;
} PtDspyMsgImage;

typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
    PtDspyUnsigned32 xmin;
    PtDspyUnsigned32 xmax;
    PtDspyUnsigned32 ymin;
    PtDspyUnsigned32 ymax;
} PtDspyMsgData;

typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
    PtDspyUnsigned32 xmin;
    PtDspyUnsigned32 xmax;
    PtDspyUnsigned32 ymin;
    PtDspyUnsigned32 ymax;
} PtDspyMsgActiveRegion;

typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
    PtDspyUnsigned32 xmin;
    PtDspyUnsigned32 xmax;
    PtDspyUnsigned32 ymin;
    PtDspyUnsigned32 ymax;
    PtDspyUnsigned32 datasize;
} PtDspyMsgDeepData;

typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
    PtDspyQueryType query;
    PtDspyUnsigned32 length;
} PtDspyMsgQuery;

typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
} PtDspyMsgClose;

typedef struct
{
    PtDspyServerMessage msg;
    PtDspyUnsigned32 id;
} PtDspyMsgMetadata;

typedef struct
{
    PtDspySigned8 vtype;
    PtDspySigned8 vcount;
    PtDspySigned8 byteorder;
    PtDspySigned8 XunusedpaddingX;
    PtDspyUnsigned32 nbytes;
    PtDspyUnsigned32 type;
} PtDspyMsgFormat;

typedef struct uparam
{
    RtConstString name;
    char vtype, vcount;
    RtPointer value;
    int nbytes;
} UserParameter;

#ifdef __cplusplus
extern "C" {
#endif

typedef PtDspyError (*PtDspyOpenFuncPtr)(PtDspyImageHandle* image, const char* drivername,
                                         const char* filename, int width, int height,
                                         int paramCount, const UserParameter* parameters,
                                         int iFormatCount, PtDspyDevFormat* format,
                                         PtFlagStuff* flagstuff);

typedef PtDspyError (*PtDspyWriteFuncPtr)(PtDspyImageHandle image, int xmin, int xmax_plus_one,
                                          int ymin, int ymax_plus_one, int entrysize,
                                          const unsigned char* data);

typedef PtDspyError (*PtDspyDeepWriteFuncPtr)(PtDspyImageHandle image, int xmin, int xmax_plus_one,
                                              int ymin, int ymax_plus_one, char* data, int datasize,
                                              PtDspyUnsigned32* pixeloffsets,
                                              PtDspyUnsigned32* pixelsizes);

typedef PtDspyError (*PtDspyActiveRegionFuncPtr)(PtDspyImageHandle image, int xmin,
                                                 int xmax_plus_one, int ymin, int ymax_plus_one);

typedef PtDspyError (*PtDspyMetadataFuncPtr)(PtDspyImageHandle image, char* metadata);

typedef PtDspyError (*PtDspyCloseFuncPtr)(PtDspyImageHandle);

typedef PtDspyError (*PtDspyFlushFuncPtr)(PtDspyImageHandle);

typedef PtDspyError (*PtDspyReopenFuncPtr)(PtDspyImageHandle image, const char* drivername,
                                           const char* filename, int width, int height,
                                           int paramCount, const UserParameter* parameters,
                                           int iFormatCount, PtDspyDevFormat* format,
                                           PtFlagStuff* flagstuff);

typedef PtDspyError (*PtDspyDelayCloseFuncPtr)(PtDspyImageHandle);

typedef PtDspyError (*PtDspyQueryFuncPtr)(PtDspyImageHandle, PtDspyQueryType, int, void*);

typedef enum
{
    k_PtDriverUnknownVersion = 0,
    k_PtDriverCurrentVersion = 1
} PtDriverVersion;

typedef struct
{
    int Version;
    PtDspyOpenFuncPtr pOpen;
    PtDspyWriteFuncPtr pWrite;
    PtDspyCloseFuncPtr pClose;
    PtDspyQueryFuncPtr pQuery;
    PtDspyActiveRegionFuncPtr pActiveRegion;
    PtDspyMetadataFuncPtr pMetadata;
} PtDspyDriverFunctionTable;

PRMANAPI void DspyMemReverseCopy(unsigned char* t, const unsigned char* s, int len);

PRMANAPI void DspyMemReverse(unsigned char* t, int len);

PRMANAPI PtDspyError DspyFindStringInParamList(RtConstString const string, char** result,
                                               int paramCount, const UserParameter* parameters);

PRMANAPI PtDspyError DspyFindMatrixInParamList(RtConstString const string, float* result,
                                               int paramCount, const UserParameter* parameters);

PRMANAPI PtDspyError DspyFindFloatInParamList(RtConstString const string, float* result,
                                              int paramCount, const UserParameter* parameters);

PRMANAPI PtDspyError DspyFindFloatsInParamList(RtConstString const string, int* resultCount,
                                               float* result, int paramCount,
                                               const UserParameter* parameters);

PRMANAPI PtDspyError DspyFindIntInParamList(RtConstString const string, int* result, int paramCount,
                                            const UserParameter* parameters);

PRMANAPI PtDspyError DspyFindIntsInParamList(RtConstString const string, int* resultCount,
                                             int* result, int paramCount,
                                             const UserParameter* parameters);

PRMANAPI PtDspyError DspyReorderFormattingRE(int formatCount, PtDspyDevFormat* format,
                                           int outFormatCount, const PtDspyDevFormat* outFormat);

PRMANAPI PtDspyError DspyReorderFormatting(int formatCount, PtDspyDevFormat* format,
                                           int outFormatCount, const PtDspyDevFormat* outFormat);

PRMANAPI void DspyError(const char* module, const char* fmt, ...);

PRMANAPI PtDspyError DspyRegisterDriver(const char* name, const PtDspyOpenFuncPtr pOpen,
                                        const PtDspyWriteFuncPtr pWrite,
                                        const PtDspyCloseFuncPtr pClose,
                                        const PtDspyQueryFuncPtr pQuery);

PRMANAPI PtDspyError DspyRegisterDriverTable(const char* name,
                                             const PtDspyDriverFunctionTable* pTable);

PRMANAPI int DspyGetNumberOfHosts();

PRMANEXPORT PtDspyError DspyImageOpen(PtDspyImageHandle* image, const char* drivername,
                                      const char* filename, int width, int height, int paramCount,
                                      const UserParameter* parameters, int iFormatCount,
                                      PtDspyDevFormat* format, PtFlagStuff* flagstuff);

PRMANEXPORT PtDspyError DspyImageData(PtDspyImageHandle image, int xmin, int xmax, int ymin,
                                      int ymax, int entrysize, const unsigned char* data);

PRMANEXPORT PtDspyError DspyImageActiveRegion(PtDspyImageHandle image, int xmin, int xmax, int ymin,
                                              int ymax);

PRMANEXPORT PtDspyError DspyImageClose(PtDspyImageHandle);

PRMANEXPORT PtDspyError DspyImageReopen(PtDspyImageHandle image, const char* drivername,
                                        const char* filename, int width, int height, int paramCount,
                                        const UserParameter* parameters, int iFormatCount,
                                        PtDspyDevFormat* format, PtFlagStuff* flagstuff);

PRMANEXPORT PtDspyError DspyImageDelayClose(PtDspyImageHandle);

PRMANEXPORT PtDspyError DspyImageQuery(PtDspyImageHandle, PtDspyQueryType, int, void*);

PRMANEXPORT PtDspyError DspyMetadata(PtDspyImageHandle, char* metadata);

PRMANEXPORT PtDspyError DspyImageDeepData(PtDspyImageHandle pvImage, int xmin, int xmax, int ymin,
                                          int ymax, char* data, int datasize, int* pixeloffsets,
                                          int* pixelsizes);

PRMAN_INLINE int DspyClamp(float value, int min, int max)
{
    int result = (int)value;
    result = min > result ? min : result;
    result = max < result ? max : result;
    return result;
}

PRMAN_INLINE float DspyLinearTosRGB(float u)
{
    return u < 0.0031308f ? 12.92f * u : 1.055f * powf(u, 0.4167f) - 0.055f;
}

PRMAN_INLINE int DspyQuantize(float value, int x, int y, int k, int min, int max, int dither)
{
    float const s_order[8][8] = {
        {
            -0.49219f,
            0.00781f,
            -0.36719f,
            0.13281f,
            -0.46094f,
            0.03906f,
            -0.33594f,
            0.16406f,
        },
        {
            0.25781f,
            -0.24219f,
            0.38281f,
            -0.11719f,
            0.28906f,
            -0.21094f,
            0.41406f,
            -0.08594f,
        },
        {
            -0.30469f,
            0.19531f,
            -0.42969f,
            0.07031f,
            -0.27344f,
            0.22656f,
            -0.39844f,
            0.10156f,
        },
        {
            0.44531f,
            -0.05469f,
            0.32031f,
            -0.17969f,
            0.47656f,
            -0.02344f,
            0.35156f,
            -0.14844f,
        },
        {
            -0.44531f,
            0.05469f,
            -0.32031f,
            0.17969f,
            -0.47656f,
            0.02344f,
            -0.35156f,
            0.14844f,
        },
        {
            0.30469f,
            -0.19531f,
            0.42969f,
            -0.07031f,
            0.27344f,
            -0.22656f,
            0.39844f,
            -0.10156f,
        },
        {
            -0.25781f,
            0.24219f,
            -0.38281f,
            0.11719f,
            -0.28906f,
            0.21094f,
            -0.41406f,
            0.08594f,
        },
        {
            0.49219f,
            -0.00781f,
            0.36719f,
            -0.13281f,
            0.46094f,
            -0.03906f,
            0.33594f,
            -0.16406f,
        },
    };
    int dx, dy;
    switch (k & 3)
    {
    case 0:
        dx = x & 7;
        dy = y & 7;
        break;
    case 1:
        dx = 7 - (y & 7);
        dy = x & 7;
        break;
    case 2:
        dx = 7 - (x & 7);
        dy = 7 - (y & 7);
        break;
    case 3:
        dx = y & 7;
        dy = 7 - (x & 7);
        break;
    }  // (k & 3)

    value *= max - min;
    if (dither) value += s_order[dy][dx] + 0.49999f;
    int result = min + (int)floorf(value);
    result = min > result ? min : result;
    result = max < result ? max : result;
    return result;
}

#ifdef __cplusplus
}
#endif

#endif /* ndef NDSPY_H */