Apertura del repositorio

indra/llkdu/CMakeLists.txt

@@ -0,0 +1,67 @@
+# -*- cmake -*-
+
+project(llkdu)
+
+# Visual Studio 2005 has a dumb bug that causes it to fail compilation
+# of KDU if building with both optimisation and /WS (treat warnings as
+# errors), even when the specific warnings that make it croak are
+# disabled.
+
+#set(VS_DISABLE_FATAL_WARNINGS ON)
+
+include(00-Common)
+include(LLCommon)
+include(LLImage)
+include(LLKDU)
+
+set(llkdu_SOURCE_FILES
+    llimagej2ckdu.cpp
+    llkdumem.cpp
+    )
+
+set(llkdu_HEADER_FILES
+    CMakeLists.txt
+    llimagej2ckdu.h
+    llkdumem.h
+    )
+
+list(APPEND llkdu_SOURCE_FILES ${llkdu_HEADER_FILES})
+
+# Our KDU package is built with KDU_X86_INTRINSICS in its .vcxproj file.
+# Unless that macro is also set for every consumer build, KDU freaks out,
+# spamming the viewer log with alignment FUD.
+set_source_files_properties(${llkdu_SOURCE_FILES}
+                            PROPERTIES
+                            COMPILE_DEFINITIONS
+                            "KDU_X86_INTRINSICS")
+
+if (USE_KDU)
+  add_library (llkdu ${llkdu_SOURCE_FILES})
+
+  target_link_libraries(llkdu ll::kdu llimage llcommon)
+  target_include_directories( llkdu  INTERFACE   ${CMAKE_CURRENT_SOURCE_DIR})
+
+  # Add tests
+  # ND: llkdu tests are very strange as they include stubs for KDU classes/methods
+  # if not having access to the right KDU version this test will fail to compile, incidentally I do not
+  # have access to a matching version of KDU and thus cannot get this tests to compile
+  if (LL_TESTS_KDU)
+    include(LLAddBuildTest)
+    include(Tut)
+    SET(llkdu_TEST_SOURCE_FILES
+      llimagej2ckdu.cpp
+      )
+    SET(llkdu_test_additional_HEADER_FILES
+      llimagej2ckdu.h
+      llkdumem.h
+      lltut.h
+      )
+
+    get_property( llimage_include_dir TARGET llimage PROPERTY INTERFACE_INCLUDE_DIRECTORIES )
+    set_property( SOURCE ${llkdu_TEST_SOURCE_FILES} PROPERTY LL_TEST_ADDITIONAL_LIBRARIES  ll::kdu llcommon)
+    set_property( SOURCE ${llkdu_TEST_SOURCE_FILES} PROPERTY LL_TEST_ADDITIONAL_INCLUDE_DIRS ${llimage_include_dir})
+
+    LL_ADD_PROJECT_UNIT_TESTS(llkdu "${llkdu_TEST_SOURCE_FILES}")
+  endif (LL_TESTS_KDU)
+
+endif (USE_KDU)

indra/llkdu/include_kdu_xxxx.h

@@ -0,0 +1,41 @@
+/**
+ * @file   include_kdu_xxxx.h
+ * @author Nat Goodspeed
+ * @date   2016-04-25
+ * @brief  
+ * 
+ * $LicenseInfo:firstyear=2016&license=viewerlgpl$
+ * Copyright (c) 2016, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+// This file specifically omits #include guards of its own: it's sort of an
+// #include macro used to wrap KDU #includes with proper incantations. Usage:
+
+// #define kdu_xxxx "kdu_compressed.h" // or whichever KDU header
+// #include "include_kdu_xxxx.h"
+// // kdu_xxxx #undef'ed by include_kdu_xxxx.h
+
+#if __clang__
+// don't *really* want to rebuild KDU so turn off specific warnings for this header
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wself-assign-field"
+#pragma clang diagnostic ignored "-Wunused-private-field"
+#pragma clang diagnostic ignored "-Woverloaded-virtual" //<FS:TS> Silence Clang warning the flag doesn't for some reason
+#include kdu_xxxx
+#pragma clang diagnostic pop
+#elif LL_WINDOWS
+// With warnings-as-errors in effect, strange relationship between
+// jp2_output_box and its subclass jp2_target in kdu_compressed.h
+// causes build failures. Specifically:
+// warning C4263: 'void kdu_supp::jp2_target::open(kdu_supp::jp2_family_tgt *)' : member function does not override any base class virtual member function
+// warning C4264: 'void kdu_supp::jp2_output_box::open(kdu_core::kdu_uint32)' : no override available for virtual member function from base 'kdu_supp::jp2_output_box'; function is hidden
+#pragma warning(push)
+#pragma warning(disable : 4263 4264)
+#include kdu_xxxx
+#pragma warning(pop)
+#else // some other platform
+#include kdu_xxxx
+#endif
+
+#undef kdu_xxxx

indra/llkdu/llimagej2ckdu.h

@@ -0,0 +1,134 @@
+/**
+ * @file llimagej2ckdu.h
+ * @brief This is an implementation of JPEG2000 encode/decode using Kakadu
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * 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
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLIMAGEJ2CKDU_H
+#define LL_LLIMAGEJ2CKDU_H
+
+#include "llimagej2c.h"
+
+//
+// KDU core header files
+//
+//#ifdef LL_DARWIN
+//#define KDU_NO_THREADS
+//#endif
+
+#include "kdu_elementary.h"
+#include "kdu_messaging.h"
+#include "kdu_params.h"
+
+#define kdu_xxxx "kdu_compressed.h"
+#include "include_kdu_xxxx.h"
+
+#include "kdu_sample_processing.h"
+#include <boost/scoped_ptr.hpp>
+#include <boost/noncopyable.hpp>
+
+class LLKDUDecodeState;
+class LLKDUMemSource;
+
+class LLImageJ2CKDU : public LLImageJ2CImpl
+{
+public:
+    enum ECodeStreamMode
+    {
+        MODE_FAST = 0,
+        MODE_RESILIENT = 1,
+        MODE_FUSSY = 2
+    };
+    LLImageJ2CKDU();
+    virtual ~LLImageJ2CKDU();
+
+protected:
+    virtual bool getMetadata(LLImageJ2C &base);
+    virtual bool decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count);
+    virtual bool encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time=0.0,
+                                bool reversible=false);
+    virtual bool initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level = -1, int* region = NULL);
+    virtual bool initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size = -1, int precincts_size = -1, int levels = 0);
+    virtual std::string getEngineInfo() const;
+
+private:
+    bool initDecode(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, ECodeStreamMode mode, S32 first_channel, S32 max_channel_count, int discard_level = -1, int* region = NULL);
+    void setupCodeStream(LLImageJ2C &base, bool keep_codestream, ECodeStreamMode mode);
+    void cleanupCodeStream();
+
+    // This method was public, but the only call to it is commented out in our
+    // own initDecode() method. I (nat 2016-08-04) don't know what it does or
+    // why. Even if it should be uncommented, it should probably still be
+    // private.
+//  void findDiscardLevelsBoundaries(LLImageJ2C &base);
+
+    // Helper class to hold a kdu_codestream, which is a handle to the
+    // underlying implementation object. When CodeStreamHolder is reset() or
+    // destroyed, it calls kdu_codestream::destroy() -- which kdu_codestream
+    // itself does not.
+    //
+    // Call through it like a smart pointer using operator->().
+    //
+    // Every RAII class must be noncopyable. For this we don't need move
+    // support.
+    class CodeStreamHolder: public boost::noncopyable
+    {
+    public:
+        ~CodeStreamHolder()
+        {
+            reset();
+        }
+
+        void reset()
+        {
+            if (mCodeStream.exists())
+            {
+                mCodeStream.destroy();
+            }
+        }
+
+        // for those few times when you need a raw kdu_codestream*
+        kdu_core::kdu_codestream* get() { return &mCodeStream; }
+        kdu_core::kdu_codestream* operator->() { return &mCodeStream; }
+
+    private:
+        kdu_core::kdu_codestream mCodeStream;
+    };
+
+    // Encode variable
+    std::unique_ptr<LLKDUMemSource> mInputp;
+    CodeStreamHolder mCodeStreamp;
+    std::unique_ptr<kdu_core::kdu_coords> mTPosp; // tile position
+    std::unique_ptr<kdu_core::kdu_dims> mTileIndicesp;
+    int mBlocksSize;
+    int mPrecinctsSize;
+    int mLevels;
+
+    // Temporary variables for in-progress decodes...
+    // We don't own this LLImageRaw. We're simply pointing to an instance
+    // passed into initDecode().
+    LLImageRaw *mRawImagep;
+    std::unique_ptr<LLKDUDecodeState> mDecodeState;
+};
+
+#endif

indra/llkdu/llkdumem.cpp

@@ -0,0 +1,199 @@
+ /**
+ * @file llkdumem.cpp
+ * @brief Helper class for kdu memory management
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * 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
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "llkdumem.h"
+#include "llerror.h"
+
+using namespace kdu_core;
+using kd_supp_image_local::image_line_buf;
+
+#if defined(LL_WINDOWS)
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
+LLKDUMemIn::LLKDUMemIn(const U8 *data,
+                       const U32 size,
+                       const U16 width,
+                       const U16 height,
+                       const U8 in_num_components,
+                       siz_params *siz)
+{
+    U8 n;
+
+    first_comp_idx = 0;
+    rows = height;
+    cols = width;
+    num_components = in_num_components;
+    alignment_bytes = 0;
+
+    for (n = 0; n < 3; ++n)
+    {
+        precision[n] = 0;
+    }
+
+    for (n = 0; n < num_components; ++n)
+    {
+        siz->set(Sdims,n,0,rows);
+        siz->set(Sdims,n,1,cols);
+        siz->set(Ssigned,n,0,false);
+        siz->set(Sprecision,n,0,8);
+    }
+    incomplete_lines = NULL;
+    free_lines = NULL;
+    num_unread_rows = rows;
+
+    mData = data;
+    mDataSize = size;
+    mCurPos = 0;
+}
+
+LLKDUMemIn::~LLKDUMemIn()
+{
+    if ((num_unread_rows > 0) || (incomplete_lines != NULL))
+    {
+        kdu_warning w;
+        w << "Not all rows of image components "
+            << first_comp_idx << " through "
+            << first_comp_idx+num_components-1
+            << " were consumed!";
+    }
+    image_line_buf *tmp;
+    while ((tmp=incomplete_lines) != NULL)
+    {
+        incomplete_lines = tmp->next;
+        delete tmp;
+    }
+    while ((tmp=free_lines) != NULL)
+    {
+        free_lines = tmp->next;
+        delete tmp;
+    }
+}
+
+
+bool LLKDUMemIn::get(int comp_idx, kdu_line_buf &line, int x_tnum)
+{
+    int idx = comp_idx - this->first_comp_idx;
+    assert((idx >= 0) && (idx < num_components));
+    x_tnum = x_tnum*num_components+idx;
+    image_line_buf *scan, *prev=NULL;
+    for (scan = incomplete_lines; scan != NULL; prev = scan, scan = scan->next)
+    {
+        assert(scan->next_x_tnum >= x_tnum);
+        if (scan->next_x_tnum == x_tnum)
+        {
+            break;
+        }
+    }
+    if (scan == NULL)
+    { // Need to read a new image line.
+        assert(x_tnum == 0); // Must consume in very specific order.
+        if (num_unread_rows == 0)
+        {
+            return false;
+        }
+        if ((scan = free_lines) == NULL)
+        {
+            scan = new image_line_buf(cols+3,num_components);
+        }
+        free_lines = scan->next;
+        if (prev == NULL)
+        {
+            incomplete_lines = scan;
+        }
+        else
+        {
+            prev->next = scan;
+        }
+
+        // Copy from image buffer into scan.
+        memcpy(scan->buf, mData+mCurPos, cols*num_components);
+        mCurPos += cols*num_components;
+
+        num_unread_rows--;
+        scan->accessed_samples = 0;
+        scan->next_x_tnum = 0;
+    }
+
+    assert((cols-scan->accessed_samples) >= line.get_width());
+
+    int comp_offset = idx;
+    kdu_byte *sp = scan->buf+num_components*scan->accessed_samples + comp_offset;
+    int n=line.get_width();
+
+    if (line.get_buf32() != NULL)
+    {
+        kdu_sample32 *dp = line.get_buf32();
+        if (line.is_absolute())
+        { // 32-bit absolute integers
+            for (; n > 0; n--, sp+=num_components, dp++)
+            {
+                dp->ival = ((kdu_int32)(*sp)) - 128;
+            }
+        }
+        else
+        { // true 32-bit floats
+            for (; n > 0; n--, sp+=num_components, dp++)
+            {
+                dp->fval = (((float)(*sp)) / 256.0F) - 0.5F;
+            }
+        }
+    }
+    else
+    {
+        kdu_sample16 *dp = line.get_buf16();
+        if (line.is_absolute())
+        { // 16-bit absolute integers
+            for (; n > 0; n--, sp+=num_components, dp++)
+            {
+                dp->ival = ((kdu_int16)(*sp)) - 128;
+            }
+        }
+        else
+        { // 16-bit normalized representation.
+            for (; n > 0; n--, sp+=num_components, dp++)
+            {
+                dp->ival = (((kdu_int16)(*sp)) - 128) << (KDU_FIX_POINT-8);
+            }
+        }
+    }
+
+    scan->next_x_tnum++;
+    if (idx == (num_components-1))
+    {
+        scan->accessed_samples += line.get_width();
+    }
+    if (scan->accessed_samples == cols)
+    { // Send empty line to free list.
+        assert(scan == incomplete_lines);
+        incomplete_lines = scan->next;
+        scan->next = free_lines;
+        free_lines = scan;
+    }
+
+  return true;
+}

indra/llkdu/llkdumem.h

@@ -0,0 +1,155 @@
+/**
+ * @file llkdumem.h
+ * @brief Helper class for kdu memory management
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * 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
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLKDUMEM_H
+#define LL_LLKDUMEM_H
+
+// Support classes for reading and writing from memory buffers in KDU
+//#ifdef LL_DARWIN
+//#define KDU_NO_THREADS
+//#endif
+
+#define kdu_xxxx "kdu_image.h"
+#include "include_kdu_xxxx.h"
+
+#include "kdu_elementary.h"
+#include "kdu_messaging.h"
+#include "kdu_params.h"
+
+#define kdu_xxxx "kdu_compressed.h"
+#include "include_kdu_xxxx.h"
+
+#include "kdu_sample_processing.h"
+#include "kdu_utils.h"
+#include "image_local.h"
+#include "stdtypes.h"
+
+class LLKDUMemSource: public kdu_core::kdu_compressed_source
+{
+public:
+    LLKDUMemSource(U8 *input_buffer, U32 size)
+    {
+        mData = input_buffer;
+        mSize = size;
+        mCurPos = 0;
+    }
+
+    ~LLKDUMemSource()
+    {
+    }
+
+    int read(kdu_core::kdu_byte *buf, int num_bytes)
+    {
+        U32 num_out;
+        num_out = num_bytes;
+
+        if ((mSize - mCurPos) < (U32)num_bytes)
+        {
+            num_out = mSize -mCurPos;
+        }
+        memcpy(buf, mData + mCurPos, num_out);
+        mCurPos += num_out;
+        return num_out;
+    }
+
+    void reset()
+    {
+        mCurPos = 0;
+    }
+
+private:
+    U8 *mData;
+    U32 mSize;
+    U32 mCurPos;
+};
+
+class LLKDUMemTarget: public kdu_core::kdu_compressed_target
+{
+public:
+    LLKDUMemTarget(U8 *output_buffer, U32 &output_size, const U32 buffer_size)
+    {
+        mData = output_buffer;
+        mSize = buffer_size;
+        mCurPos = 0;
+        mOutputSize = &output_size;
+    }
+
+    ~LLKDUMemTarget()
+    {
+    }
+
+    bool write(const kdu_core::kdu_byte *buf, int num_bytes)
+    {
+        U32 num_out;
+        num_out = num_bytes;
+
+        if ((mSize - mCurPos) < (U32)num_bytes)
+        {
+            num_out = mSize - mCurPos;
+            memcpy(mData + mCurPos, buf, num_out);
+            return false;
+        }
+        memcpy(mData + mCurPos, buf, num_out);
+        mCurPos += num_out;
+        *mOutputSize = mCurPos;
+        return true;
+    }
+
+private:
+    U8 *mData;
+    U32 mSize;
+    U32 mCurPos;
+    U32 *mOutputSize;
+};
+
+class LLKDUMemIn : public kdu_supp::kdu_image_in_base
+{
+public:
+    LLKDUMemIn(const U8 *data,
+                const U32 size,
+                const U16 rows,
+                const U16 cols,
+                U8 in_num_components,
+                kdu_core::siz_params *siz);
+    ~LLKDUMemIn();
+
+    bool get(int comp_idx, kdu_core::kdu_line_buf &line, int x_tnum);
+
+private:
+    const U8 *mData;
+    int first_comp_idx;
+    int num_components;
+    int rows, cols;
+    int alignment_bytes; // Number of 0's at end of each line.
+    int precision[3];
+    kd_supp_image_local::image_line_buf *incomplete_lines; // Each "sample" represents a full pixel
+    kd_supp_image_local::image_line_buf *free_lines;
+    int num_unread_rows;
+
+    U32 mCurPos;
+    U32 mDataSize;
+};
+#endif

indra/llkdu/tests/llimagej2ckdu_test.cpp

@@ -0,0 +1,321 @@
+/**
+ * @file llimagej2ckdu_test.cpp
+ * @author Merov Linden
+ * @date 2010-12-17
+ *
+ * $LicenseInfo:firstyear=2006&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * 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
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+// Class to test
+#include "llimagej2ckdu.h"
+
+#if __clang__
+// For this source, it's true that private fields in llkdumem.h are unused.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+#include "llkdumem.h"
+#pragma clang diagnostic pop
+#else
+#include "llkdumem.h"
+#endif
+#include "kdu_block_coding.h"
+// Tut header
+#include "lltut.h"
+
+// -------------------------------------------------------------------------------------------
+// Stubbing: Declarations required to link and run the class being tested
+// Notes:
+// * Add here stubbed implementation of the few classes and methods used in the class to be tested
+// * Add as little as possible (let the link errors guide you)
+// * Do not make any assumption as to how those classes or methods work (i.e. don't copy/paste code)
+// * A simulator for a class can be implemented here. Please comment and document thoroughly.
+
+// End Stubbing
+// -------------------------------------------------------------------------------------------
+// Stub the LL Image Classes
+//LLTrace::MemStatHandle    LLImageBase::sMemStat("LLImage");
+
+LLImageRaw::LLImageRaw() { }
+LLImageRaw::~LLImageRaw() { }
+U8* LLImageRaw::allocateData(S32 ) { return NULL; }
+void LLImageRaw::deleteData() { }
+U8* LLImageRaw::reallocateData(S32 ) { return NULL; }
+bool LLImageRaw::resize(U16, U16, S8) { return true; } // this method always returns true...
+
+LLImageBase::LLImageBase()
+: mData(NULL),
+mDataSize(0),
+mWidth(0),
+mHeight(0),
+mComponents(0),
+mBadBufferAllocation(false),
+mAllowOverSize(false)
+{ }
+LLImageBase::~LLImageBase() { }
+U8* LLImageBase::allocateData(S32 ) { return NULL; }
+void LLImageBase::deleteData() { }
+void LLImageBase::dump() { }
+const U8* LLImageBase::getData() const { return NULL; }
+U8* LLImageBase::getData() { return NULL; }
+U8* LLImageBase::reallocateData(S32 ) { return NULL; }
+void LLImageBase::sanityCheck() { }
+void LLImageBase::setSize(S32 , S32 , S32 ) { }
+
+LLImageJ2CImpl::~LLImageJ2CImpl() { }
+
+LLImageFormatted::LLImageFormatted(S8 ) { }
+LLImageFormatted::~LLImageFormatted() { }
+U8* LLImageFormatted::allocateData(S32 ) { return NULL; }
+S32 LLImageFormatted::calcDataSize(S32 ) { return 0; }
+S32 LLImageFormatted::calcDiscardLevelBytes(S32 ) { return 0; }
+bool LLImageFormatted::decodeChannels(LLImageRaw*, F32, S32, S32) { return false; }
+bool LLImageFormatted::copyData(U8 *, S32) { return true; }  // this method always returns true...
+void LLImageFormatted::deleteData() { }
+void LLImageFormatted::dump() { }
+U8* LLImageFormatted::reallocateData(S32 ) { return NULL; }
+void LLImageFormatted::resetLastError() { }
+void LLImageFormatted::sanityCheck() { }
+void LLImageFormatted::setLastError(const std::string& , const std::string& ) { }
+
+LLImageJ2C::LLImageJ2C() : LLImageFormatted(IMG_CODEC_J2C), mRate(DEFAULT_COMPRESSION_RATE) { }
+LLImageJ2C::~LLImageJ2C() { }
+S32 LLImageJ2C::calcDataSize(S32 ) { return 0; }
+S32 LLImageJ2C::calcDiscardLevelBytes(S32 ) { return 0; }
+S32 LLImageJ2C::calcHeaderSize() { return 0; }
+bool LLImageJ2C::decode(LLImageRaw*, F32) { return false; }
+bool LLImageJ2C::decodeChannels(LLImageRaw*, F32, S32, S32 ) { return false; }
+void LLImageJ2C::decodeFailed() { }
+bool LLImageJ2C::encode(const LLImageRaw*, F32) { return false; }
+S8  LLImageJ2C::getRawDiscardLevel() { return 0; }
+void LLImageJ2C::resetLastError() { }
+void LLImageJ2C::setLastError(const std::string&, const std::string&) { }
+bool LLImageJ2C::updateData() { return false; }
+void LLImageJ2C::updateRawDiscardLevel() { }
+
+LLKDUMemIn::LLKDUMemIn(const U8*, const U32, const U16, const U16, const U8, kdu_core::siz_params*) { }
+LLKDUMemIn::~LLKDUMemIn() { }
+bool LLKDUMemIn::get(int, kdu_core::kdu_line_buf&, int) { return false; }
+
+// Stub Kakadu Library calls
+// they're all namespaced now
+namespace kdu_core_local
+{
+    class kd_coremem;
+}
+namespace kdu_core {
+kdu_tile_comp kdu_tile::access_component(int ) { kdu_tile_comp a; return a; }
+kdu_block_encoder::kdu_block_encoder() { }
+kdu_block_decoder::kdu_block_decoder() { }
+void kdu_block::set_max_passes(int , bool ) { }
+void kdu_block::set_max_bytes(int , bool ) { }
+void kdu_tile::close(kdu_thread_env *, bool) {}
+int kdu_tile::get_num_components() { return 0; }
+bool kdu_tile::get_ycc() { return false; }
+void kdu_tile::set_components_of_interest(int , const int* ) { }
+int kdu_tile::get_tnum() { return 0; }
+kdu_resolution kdu_tile_comp::access_resolution() { kdu_resolution a; return a; }
+kdu_resolution kdu_tile_comp::access_resolution(int ) { kdu_resolution a; return a; }
+int kdu_tile_comp::get_bit_depth(bool ) { return 8; }
+bool kdu_tile_comp::get_reversible() { return false; }
+int kdu_tile_comp::get_num_resolutions() { return 1; }
+kdu_subband kdu_resolution::access_subband(int ) { kdu_subband a; return a; }
+void kdu_resolution::get_dims(kdu_dims& ) { }
+int kdu_resolution::which() { return 0; }
+int kdu_resolution::get_valid_band_indices(int &) { return 1; }
+kdu_synthesis::kdu_synthesis(kdu_resolution, kdu_sample_allocator*, bool, float, kdu_thread_env*, kdu_thread_queue*) { }
+//kdu_params::kdu_params(const char*, bool, bool, bool, bool, bool) { }
+kdu_params::kdu_params(const char*, bool, bool, bool, bool, bool, kd_core_local::kd_coremem*) {}
+kdu_params::~kdu_params() { }
+void kdu_params::set(const char* , int , int , bool ) { }
+void kdu_params::set(const char* , int , int , int ) { }
+void kdu_params::finalize_all(bool ) { }
+void kdu_params::finalize_all(int, bool ) { }
+void kdu_params::copy_from(kdu_params*, int, int, int, int, int, bool, bool, bool) { }
+bool kdu_params::parse_string(const char*) { return false; }
+bool kdu_params::get(const char*, int, int, bool&, bool, bool, bool) { return false; }
+bool kdu_params::get(const char*, int, int, float&, bool, bool, bool) { return false; }
+bool kdu_params::get(const char*, int, int, int&, bool, bool, bool) { return false; }
+kdu_params* kdu_params::access_relation(int, int, int, bool) { return NULL; }
+kdu_params* kdu_params::access_cluster(const char*) { return NULL; }
+void kdu_codestream::set_fast() { }
+void kdu_codestream::set_fussy() { }
+void kdu_codestream::get_dims(int, kdu_dims&, bool ) { }
+int kdu_codestream::get_min_dwt_levels() { return 5; }
+int kdu_codestream::get_max_tile_layers() { return 1; }
+void kdu_codestream::change_appearance(bool, bool, bool, kdu_thread_env *) {}
+void kdu_codestream::get_tile_dims(kdu_coords, int, kdu_dims&, bool ) { }
+void kdu_codestream::destroy() { }
+void kdu_codestream::collect_timing_stats(int ) { }
+void kdu_codestream::set_max_bytes(kdu_long, bool, bool ) { }
+void kdu_codestream::get_valid_tiles(kdu_dims& ) { }
+void kdu_codestream::create(
+    siz_params*,
+    kdu_compressed_target*,
+    kdu_dims*,
+    int,
+    kdu_long,
+    kdu_thread_env*,
+    kdu_membroker*) {}
+void kdu_codestream::create(kdu_compressed_source *,kdu_thread_env *, kdu_membroker *) {}
+void kdu_codestream::apply_input_restrictions(int, int, int, int, kdu_dims const *, kdu_component_access_mode, kdu_thread_env *, kdu_quality_limiter const *) {}
+void kdu_codestream::get_subsampling(int , kdu_coords&, bool ) { }
+void kdu_codestream::flush(kdu_long *, int, kdu_uint16 *, bool, bool, double, kdu_thread_env*, int) { }
+void kdu_codestream::set_resilient(bool ) { }
+int kdu_codestream::get_num_components(bool ) { return 0; }
+kdu_long kdu_codestream::get_total_bytes(bool ) { return 0; }
+kdu_long kdu_codestream::get_compressed_data_memory(bool ) const {return 0; }
+void kdu_codestream::share_buffering(kdu_codestream ) { }
+int kdu_codestream::get_num_tparts() { return 0; }
+int kdu_codestream::trans_out(kdu_long, kdu_long*, int, bool, kdu_thread_env* ) { return 0; }
+bool kdu_codestream::ready_for_flush(kdu_thread_env*) { return false; }
+siz_params* kdu_codestream::access_siz() { return NULL; }
+kdu_tile kdu_codestream::open_tile(kdu_coords , kdu_thread_env* ) { kdu_tile a; return a; }
+kdu_codestream_comment kdu_codestream::add_comment(kdu_thread_env*) { kdu_codestream_comment a; return a; }
+void kdu_subband::close_block(kdu_block*, kdu_thread_env*) { }
+void kdu_subband::get_valid_blocks(kdu_dims &indices) const { }
+kdu_block * kdu_subband::open_block(kdu_coords, int *, kdu_thread_env *, int, bool) { return NULL; }
+bool kdu_codestream_comment::put_text(const char*) { return false; }
+void kdu_customize_warnings(kdu_message*) { }
+void kdu_customize_errors(kdu_message*) { }
+kdu_long kdu_multi_analysis::create(
+    kdu_codestream,
+    kdu_tile,
+    kdu_thread_env*,
+    kdu_thread_queue*,
+    int,
+    kdu_roi_image*,
+    int,
+    kdu_sample_allocator*,
+    const kdu_push_pull_params*,
+    kdu_membroker*) { return kdu_long(0); }
+void kdu_multi_analysis::destroy(kdu_thread_env *) {}
+siz_params::siz_params(kd_core_local::kd_coremem*) : kdu_params(NULL, false, false, false, false, false) { }
+siz_params::~siz_params() {}
+void siz_params::finalize(bool ) { }
+void siz_params::copy_with_xforms(kdu_params*, int, int, bool, bool, bool) { }
+int siz_params::write_marker_segment(kdu_output*, kdu_params*, int) { return 0; }
+bool siz_params::check_marker_segment(kdu_uint16, int, kdu_byte a[], int&) { return false; }
+bool siz_params::read_marker_segment(kdu_uint16, int, kdu_byte a[], int) { return false; }
+kdu_decoder::kdu_decoder(
+    kdu_subband subband,
+    kdu_sample_allocator*,
+    bool, float, int,
+    kdu_thread_env*,
+    kdu_thread_queue*,
+    int, float*) {}
+kdu_sample_allocator::~kdu_sample_allocator() {}
+void kdu_sample_allocator::do_finalize(kdu_codestream) {}
+void (*kdu_convert_ycc_to_rgb_rev16)(kdu_int16*,kdu_int16*,kdu_int16*,int);
+void (*kdu_convert_ycc_to_rgb_irrev16)(kdu_int16*,kdu_int16*,kdu_int16*,int);
+void (*kdu_convert_ycc_to_rgb_rev32)(kdu_int32*,kdu_int32*,kdu_int32*,int);
+void (*kdu_convert_ycc_to_rgb_irrev32)(float*,float*,float*,int);
+bool kdu_core_sample_alignment_checker(int, int, int, int, bool, bool) { return false; }
+void kdu_pull_ifc::destroy() {}
+void kdu_sample_allocator::advance_pre_frag() {}
+void kdu_params::operator delete(void *) {}
+} // namespace kdu_core
+
+// -------------------------------------------------------------------------------------------
+// TUT
+// -------------------------------------------------------------------------------------------
+
+namespace tut
+{
+    // Test wrapper declarations
+    struct llimagej2ckdu_test
+    {
+        // Derived test class
+        class LLTestImageJ2CKDU : public LLImageJ2CKDU
+        {
+        public:
+            // Provides public access to some protected methods for testing
+            bool callGetMetadata(LLImageJ2C &base) { return getMetadata(base); }
+            bool callDecodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count)
+            {
+                return decodeImpl(base, raw_image, decode_time, first_channel, max_channel_count);
+            }
+            bool callEncodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text)
+            {
+                return encodeImpl(base, raw_image, comment_text);
+            }
+        };
+        // Instance to be tested
+        LLTestImageJ2CKDU* mImage;
+
+        // Constructor and destructor of the test wrapper
+        llimagej2ckdu_test()
+        {
+            mImage = new LLTestImageJ2CKDU;
+        }
+        ~llimagej2ckdu_test()
+        {
+            delete mImage;
+        }
+    };
+
+    // Tut templating thingamagic: test group, object and test instance
+    typedef test_group<llimagej2ckdu_test> llimagej2ckdu_t;
+    typedef llimagej2ckdu_t::object llimagej2ckdu_object_t;
+    tut::llimagej2ckdu_t tut_llimagej2ckdu("LLImageJ2CKDU");
+
+    // ---------------------------------------------------------------------------------------
+    // Test functions
+    // Notes:
+    // * Test as many as you possibly can without requiring a full blown simulation of everything
+    // * The tests are executed in sequence so the test instance state may change between calls
+    // * Remember that you cannot test private methods with tut
+    // ---------------------------------------------------------------------------------------
+
+    // Test 1 : test getMetadata()
+    template<> template<>
+    void llimagej2ckdu_object_t::test<1>()
+    {
+        LLImageJ2C* image = new LLImageJ2C();
+        bool res = mImage->callGetMetadata(*image);
+        // Trying to set up a data stream with all NIL values and stubbed KDU will "work" and return true
+        // Note that is linking with KDU, that call will throw an exception and fail, returning false
+        ensure("getMetadata() test failed", res);
+    }
+
+    // Test 2 : test decodeImpl()
+    template<> template<>
+    void llimagej2ckdu_object_t::test<2>()
+    {
+        LLImageJ2C* image = new LLImageJ2C();
+        LLImageRaw* raw = new LLImageRaw();
+        bool res = mImage->callDecodeImpl(*image, *raw, 0.0, 0, 0);
+        // Decoding returns true whenever there's nothing else to do, including if decoding failed, so we'll get true here
+        ensure("decodeImpl() test failed", res);
+    }
+
+    // Test 3 : test encodeImpl()
+    template<> template<>
+    void llimagej2ckdu_object_t::test<3>()
+    {
+        LLImageJ2C* image = new LLImageJ2C();
+        LLImageRaw* raw = new LLImageRaw();
+        bool res = mImage->callEncodeImpl(*image, *raw, NULL);
+        // Encoding returns true unless an exception was raised, so we'll get true here though nothing really was done
+        ensure("encodeImpl() test failed", res);
+    }
+}