plugins/compressor.h

Go to the documentation of this file.

/* Copyright (c) 2009-2010, Cedric Stalder <cedric.stalder@gmail.com>
 *               2009-2012, Stefan Eilemann <eile@equalizergraphics.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQ_PLUGINS_COMPRESSOR
#define EQ_PLUGINS_COMPRESSOR

#include <sys/types.h>
struct GLEWContextStruct;
struct WGLEWContextStruct;
typedef struct GLEWContextStruct GLEWContext;
typedef struct WGLEWContextStruct WGLEWContext;
typedef unsigned long long eq_uint64_t;

#ifdef _MSC_VER
#  ifdef EQ_PLUGIN_BUILD
#    define EQ_PLUGIN_API __declspec(dllexport)
#  else
#    define EQ_PLUGIN_API __declspec(dllimport)
#  endif
#else // _WIN32
#  define EQ_PLUGIN_API __attribute__ ((visibility("default")))
#endif

#define EQ_COMPRESSOR_VERSION 4

#define EQ_COMPRESSOR_VERSION_1 1

#define EQ_COMPRESSOR_VERSION_2 1

#define EQ_COMPRESSOR_VERSION_3 1

#define EQ_COMPRESSOR_VERSION_4 1

#include "compressorTokens.h"
#include "compressorTypes.h"

#ifdef __cplusplus
#include <iostream>
extern "C"
{
#endif

    #define EQ_COMPRESSOR_INPLACE    0x1

    #define EQ_COMPRESSOR_DATA_1D    0x2

    #define EQ_COMPRESSOR_DATA_2D    0x4

    #define EQ_COMPRESSOR_IGNORE_ALPHA 0x8

    #define EQ_COMPRESSOR_IGNORE_MSE EQ_COMPRESSOR_IGNORE_ALPHA

    #define EQ_COMPRESSOR_CPU 0

    #define EQ_COMPRESSOR_TRANSFER 0x10

    #define EQ_COMPRESSOR_USE_TEXTURE_RECT 0x20

    #define EQ_COMPRESSOR_USE_TEXTURE_2D 0x80

    #define EQ_COMPRESSOR_USE_FRAMEBUFFER 0x40

    #define EQ_COMPRESSOR_USE_ASYNC_DOWNLOAD 0x100

#if 0 // Not implemented yet

    #define EQ_COMPRESSOR_USE_ASYNC_UPLOAD 0x200
#endif

    struct EqCompressorInfo
    {
        unsigned version;

        unsigned name;

        unsigned tokenType;

        eq_uint64_t capabilities;

        float quality;

        float ratio;

        float speed;

        unsigned outputTokenType;

        unsigned outputTokenSize;
    };

    EQ_PLUGIN_API size_t EqCompressorGetNumCompressors();

    EQ_PLUGIN_API void EqCompressorGetInfo( const size_t n,
                                            EqCompressorInfo* const info );
    EQ_PLUGIN_API void* EqCompressorNewCompressor( const unsigned name );

    EQ_PLUGIN_API void EqCompressorDeleteCompressor( void* const compressor );

    EQ_PLUGIN_API void* EqCompressorNewDecompressor( const unsigned name );

    EQ_PLUGIN_API void EqCompressorDeleteDecompressor(void* const decompressor);
    EQ_PLUGIN_API void EqCompressorCompress( void* const compressor,
                                             const unsigned name,
                                             void* const in,
                                             const eq_uint64_t* inDims,
                                             const eq_uint64_t flags );

    EQ_PLUGIN_API unsigned EqCompressorGetNumResults( void* const compressor,
                                                      const unsigned name );

    EQ_PLUGIN_API void EqCompressorGetResult( void* const compressor,
                                              const unsigned name,
                                              const unsigned i,
                                              void** const out,
                                              eq_uint64_t* const outSize );

    EQ_PLUGIN_API void EqCompressorDecompress( void* const decompressor,
                                               const unsigned name,
                                               const void* const* in,
                                               const eq_uint64_t* const inSizes,
                                               const unsigned numInputs,
                                               void* const out,
                                               eq_uint64_t* const outDims,
                                               const eq_uint64_t flags );
    EQ_PLUGIN_API bool EqCompressorIsCompatible( const unsigned name,
                                               const GLEWContext* glewContext );

    EQ_PLUGIN_API void EqCompressorDownload( void* const        compressor,
                                             const unsigned     name,
                                             const GLEWContext* glewContext,
                                             const eq_uint64_t  inDims[4],
                                             const unsigned     source,
                                             const eq_uint64_t  flags,
                                             eq_uint64_t        outDims[4],
                                             void**             out );

    EQ_PLUGIN_API void EqCompressorStartDownload( void* const        compressor,
                                                  const unsigned     name,
                                                 const GLEWContext* glewContext,
                                                  const eq_uint64_t  inDims[4],
                                                  const unsigned     source,
                                                  const eq_uint64_t  flags );

    EQ_PLUGIN_API void EqCompressorFinishDownload( void* const compressor,
                                                   const unsigned     name,
                                                 const GLEWContext* glewContext,
                                                   const eq_uint64_t  inDims[4],
                                                   const eq_uint64_t  flags,
                                                   eq_uint64_t outDims[4],
                                                   void**             out );

    EQ_PLUGIN_API void EqCompressorUpload( void* const        decompressor,
                                           const unsigned     name,
                                           const GLEWContext* glewContext,
                                           const void*        buffer,
                                           const eq_uint64_t  inDims[4],
                                           const eq_uint64_t  flags,
                                           const eq_uint64_t  outDims[4],
                                           const unsigned     destination );
#if 0
    // TODO: add EqCompressorStart/FinishUpload and document operations and
    // parameters
#endif

#ifdef __cplusplus
} // extern "C"

inline std::ostream& operator << ( std::ostream& os,
                                   const EqCompressorInfo& info )
{
    return os << std::hex << "name 0x" << info.name << " in 0x"
              << info.tokenType << " out 0x" << info.outputTokenType
              << " cap 0x" << info.capabilities << std::dec << " quality "
              << info.quality <<" ratio " << info.ratio << " speed "
              << info.speed << " v" << info.version;
}
#endif
#endif // EQ_PLUGINS_COMPRESSOR