Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

2 files changed, 863 insertions, 863 deletions

diff --git a/indra/llimagej2coj/llimagej2coj.cpp b/indra/llimagej2coj/llimagej2coj.cpp
index 482d2a2c8a..2ac125c62f 100644
--- a/indra/llimagej2coj/llimagej2coj.cpp
+++ b/indra/llimagej2coj/llimagej2coj.cpp
@@ -1,849 +1,849 @@
-/** 
- * @file llimagej2coj.cpp
- * @brief This is an implementation of JPEG2000 encode/decode using OpenJPEG.
- *
- * $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"
-#include "llimagej2coj.h"
-
-// this is defined so that we get static linking.
-#include "openjpeg.h"
-#include "event.h"
-#include "cio.h"
-
-#define MAX_ENCODED_DISCARD_LEVELS 5
-
-// Factory function: see declaration in llimagej2c.cpp
-LLImageJ2CImpl* fallbackCreateLLImageJ2CImpl()
-{
-    return new LLImageJ2COJ();
-}
-
-std::string LLImageJ2COJ::getEngineInfo() const
-{
-#ifdef OPENJPEG_VERSION
-    return std::string("OpenJPEG: " OPENJPEG_VERSION ", Runtime: ")
-        + opj_version();
-#else
-    return std::string("OpenJPEG runtime: ") + opj_version();
-#endif
-}
-
-// Return string from message, eliminating final \n if present
-static std::string chomp(const char* msg)
-{
-    // stomp trailing \n
-    std::string message = msg;
-    if (!message.empty())
-    {
-        size_t last = message.size() - 1;
-        if (message[last] == '\n')
-        {
-            message.resize(last);
-        }
-}
-    return message;
-}
-
-/**
-sample error callback expecting a LLFILE* client object
-*/
-void error_callback(const char* msg, void*)
-{
-    LL_DEBUGS() << "LLImageJ2COJ: " << chomp(msg) << LL_ENDL;
-}
-/**
-sample warning callback expecting a LLFILE* client object
-*/
-void warning_callback(const char* msg, void*)
-{
-    LL_DEBUGS() << "LLImageJ2COJ: " << chomp(msg) << LL_ENDL;
-}
-/**
-sample debug callback expecting no client object
-*/
-void info_callback(const char* msg, void*)
-{
-    LL_DEBUGS() << "LLImageJ2COJ: " << chomp(msg) << LL_ENDL;
-}
-
-// Divide a by 2 to the power of b and round upwards
-int ceildivpow2(int a, int b)
-{
-    return (a + (1 << b) - 1) >> b;
-}
-
-class JPEG2KBase
-{
-public:
-    JPEG2KBase() {}
-
-    U8*        buffer = nullptr;
-    OPJ_SIZE_T size = 0;
-    OPJ_OFF_T  offset = 0;
-};
-
-#define WANT_VERBOSE_OPJ_SPAM LL_DEBUG
-
-static void opj_info(const char* msg, void* user_data)
-{
-    llassert(user_data);
-#if WANT_VERBOSE_OPJ_SPAM
-    LL_INFOS("OpenJPEG") << msg << LL_ENDL;
-#endif
-}
-
-static void opj_warn(const char* msg, void* user_data)
-{
-    llassert(user_data);
-#if WANT_VERBOSE_OPJ_SPAM
-    LL_WARNS("OpenJPEG") << msg << LL_ENDL;
-#endif
-}
-
-static void opj_error(const char* msg, void* user_data)
-{
-    llassert(user_data);
-#if WANT_VERBOSE_OPJ_SPAM
-    LL_WARNS("OpenJPEG") << msg << LL_ENDL;
-#endif
-}
-
-static OPJ_SIZE_T opj_read(void * buffer, OPJ_SIZE_T bytes, void* user_data)
-{
-    llassert(user_data);
-    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);
-    OPJ_SIZE_T remainder = (jpeg_codec->size - jpeg_codec->offset);
-    if (remainder <= 0)
-    {
-        jpeg_codec->offset = jpeg_codec->size;
-        // Indicate end of stream (hacky?)
-        return (OPJ_OFF_T)-1;
-    }
-    OPJ_SIZE_T to_read = llclamp(U32(bytes), U32(0), U32(remainder));
-    memcpy(buffer, jpeg_codec->buffer + jpeg_codec->offset, to_read);
-    jpeg_codec->offset += to_read;
-    return to_read;
-}
-
-static OPJ_SIZE_T opj_write(void * buffer, OPJ_SIZE_T bytes, void* user_data)
-{
-    llassert(user_data);
-    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);
-    OPJ_SIZE_T remainder = jpeg_codec->size - jpeg_codec->offset;
-    if (remainder < bytes)
-    {
-        OPJ_SIZE_T new_size = jpeg_codec->size + (bytes - remainder);
-        U8* new_buffer = (U8*)ll_aligned_malloc_16(new_size);
-        memcpy(new_buffer, jpeg_codec->buffer, jpeg_codec->offset);
-        U8* old_buffer = jpeg_codec->buffer;
-        jpeg_codec->buffer = new_buffer;
-        ll_aligned_free_16(old_buffer);
-        jpeg_codec->size = new_size;
-    }
-    memcpy(jpeg_codec->buffer + jpeg_codec->offset, buffer, bytes);
-    jpeg_codec->offset += bytes;
-    return bytes;
-}
-
-static OPJ_OFF_T opj_skip(OPJ_OFF_T bytes, void* user_data)
-{
-    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);
-    jpeg_codec->offset += bytes;
-
-    if (jpeg_codec->offset > jpeg_codec->size)
-    {
-        jpeg_codec->offset = jpeg_codec->size;
-        // Indicate end of stream
-        return (OPJ_OFF_T)-1;
-    }
-
-    if (jpeg_codec->offset < 0)
-    {
-        // Shouldn't be possible?
-        jpeg_codec->offset = 0;
-        return (OPJ_OFF_T)-1;
-    }
-
-    return bytes;
-}
-
-static OPJ_BOOL opj_seek(OPJ_OFF_T bytes, void * user_data)
-{
-    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);
-    jpeg_codec->offset = bytes;
-    jpeg_codec->offset = llclamp(U32(jpeg_codec->offset), U32(0), U32(jpeg_codec->size));
-    return OPJ_TRUE;
-}
-
-static void opj_free_user_data(void * user_data)
-{
-    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);
-    // Don't free, data is managed externally
-    jpeg_codec->buffer = nullptr;
-    jpeg_codec->size = 0;
-    jpeg_codec->offset = 0;
-}
-
-static void opj_free_user_data_write(void * user_data)
-{
-    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);
-    // Free, data was allocated here
-    ll_aligned_free_16(jpeg_codec->buffer);
-    jpeg_codec->buffer = nullptr;
-    jpeg_codec->size = 0;
-    jpeg_codec->offset = 0;
-}
-
-class JPEG2KDecode : public JPEG2KBase
-{
-public:
-
-    JPEG2KDecode(S8 discardLevel)
-    {
-        memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
-        memset(&parameters, 0, sizeof(opj_dparameters_t));
-        event_mgr.error_handler = error_callback;
-        event_mgr.warning_handler = warning_callback;
-        event_mgr.info_handler = info_callback;
-        opj_set_default_decoder_parameters(&parameters);
-        parameters.cp_reduce = discardLevel;
-    }
-
-    ~JPEG2KDecode()
-    {
-        if (decoder)
-        {
-            opj_destroy_codec(decoder);
-        }
-        decoder = nullptr;
-
-        if (image)
-        {
-            opj_image_destroy(image);
-        }
-        image = nullptr;
-
-        if (stream)
-        {
-            opj_stream_destroy(stream);
-        }
-        stream = nullptr;
-
-        if (codestream_info)
-        {
-            opj_destroy_cstr_info(&codestream_info);
-        }
-        codestream_info = nullptr;
-    }
-
-    bool readHeader(
-        U8* data,
-        U32 dataSize,
-        S32& widthOut,
-        S32& heightOut,
-        S32& components,
-        S32& discard_level)
-    {
-        parameters.flags |= OPJ_DPARAMETERS_DUMP_FLAG;
-
-        decoder = opj_create_decompress(OPJ_CODEC_J2K);
-
-        if (!opj_setup_decoder(decoder, &parameters))
-        {
-            return false;
-        }
-
-        if (stream)
-        {
-            opj_stream_destroy(stream);
-        }
-
-        stream = opj_stream_create(dataSize, true);
-        if (!stream)
-        {
-            return false;
-        }
-
-        opj_stream_set_user_data(stream, this, opj_free_user_data);
-        opj_stream_set_user_data_length(stream, dataSize);
-        opj_stream_set_read_function(stream, opj_read);
-        opj_stream_set_write_function(stream, opj_write);
-        opj_stream_set_skip_function(stream, opj_skip);
-        opj_stream_set_seek_function(stream, opj_seek);
-
-        buffer = data;
-        size = dataSize;
-        offset = 0;
-
-        // enable decoding partially loaded images
-        opj_decoder_set_strict_mode(decoder, OPJ_FALSE);
-
-        /* Read the main header of the codestream and if necessary the JP2 boxes*/
-        if (!opj_read_header((opj_stream_t*)stream, decoder, &image))
-        {
-            return false;
-        }
-
-        codestream_info = opj_get_cstr_info(decoder);
-
-        if (!codestream_info)
-        {
-            return false;
-        }
-
-        U32 tileDimX = codestream_info->tdx;
-        U32 tileDimY = codestream_info->tdy;
-        U32 tilesW = codestream_info->tw;
-        U32 tilesH = codestream_info->th;
-
-        widthOut = S32(tilesW * tileDimX);
-        heightOut = S32(tilesH * tileDimY);
-        components = codestream_info->nbcomps;
-
-        discard_level = 0;
-        while (tilesW > 1 && tilesH > 1 && discard_level < MAX_DISCARD_LEVEL)
-        {
-            discard_level++;
-            tilesW >>= 1;
-            tilesH >>= 1;
-        }
-
-        return true;
-    }
-
-    bool decode(U8* data, U32 dataSize, U32* channels, U8 discard_level)
-    {
-        parameters.flags &= ~OPJ_DPARAMETERS_DUMP_FLAG;
-
-        decoder = opj_create_decompress(OPJ_CODEC_J2K);
-        opj_setup_decoder(decoder, &parameters);
-
-        opj_set_info_handler(decoder, opj_info, this);
-        opj_set_warning_handler(decoder, opj_warn, this);
-        opj_set_error_handler(decoder, opj_error, this);
-
-        if (stream)
-        {
-            opj_stream_destroy(stream);
-        }
-
-        stream = opj_stream_create(dataSize, true);
-        if (!stream)
-        {
-            return false;
-        }
-
-        opj_stream_set_user_data(stream, this, opj_free_user_data);
-        opj_stream_set_user_data_length(stream, dataSize);
-        opj_stream_set_read_function(stream, opj_read);
-        opj_stream_set_write_function(stream, opj_write);
-        opj_stream_set_skip_function(stream, opj_skip);
-        opj_stream_set_seek_function(stream, opj_seek);
-
-        buffer = data;
-        size = dataSize;
-        offset = 0;
-
-        if (image)
-        {
-            opj_image_destroy(image);
-            image = nullptr;
-        }
-
-        // needs to happen before opj_read_header and opj_decode...
-        opj_set_decoded_resolution_factor(decoder, discard_level);
-
-        // enable decoding partially loaded images
-        opj_decoder_set_strict_mode(decoder, OPJ_FALSE);
-
-        if (!opj_read_header(stream, decoder, &image))
-        {
-            return false;
-        }
-
-        // needs to happen before decode which may fail
-        if (channels)
-        {
-            *channels = image->numcomps;
-        }
-
-        OPJ_BOOL decoded = opj_decode(decoder, stream, image);
-
-        // count was zero.  The latter is just a sanity check before we
-        // dereference the array.
-        if (!decoded || !image || !image->numcomps)
-        {
-            opj_end_decompress(decoder, stream);
-            return false;
-        }
-
-        opj_end_decompress(decoder, stream);
-
-        return true;
-    }
-
-    opj_image_t* getImage() { return image; }
-
-private:
-    opj_dparameters_t         parameters;
-    opj_event_mgr_t           event_mgr;
-    opj_image_t*              image = nullptr;
-    opj_codec_t*              decoder = nullptr;
-    opj_stream_t*             stream = nullptr;
-    opj_codestream_info_v2_t* codestream_info = nullptr;
-};
-
-class JPEG2KEncode : public JPEG2KBase
-{
-public:
-    const OPJ_UINT32 TILE_SIZE = 64 * 64 * 3;
-
-    JPEG2KEncode(const char* comment_text_in, bool reversible)
-    {
-        memset(&parameters, 0, sizeof(opj_cparameters_t));
-        memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
-        event_mgr.error_handler = error_callback;
-        event_mgr.warning_handler = warning_callback;
-        event_mgr.info_handler = info_callback;
-
-        opj_set_default_encoder_parameters(&parameters);
-        parameters.cod_format = OPJ_CODEC_J2K;
-        parameters.cp_disto_alloc = 1;
-        parameters.max_cs_size = (1 << 15);
-
-        if (reversible)
-        {
-            parameters.tcp_numlayers = 1;
-            parameters.tcp_rates[0] = 1.0f;
-        }
-        else
-        {
-            parameters.tcp_numlayers = 5;
-            parameters.tcp_rates[0] = 1920.0f;
-            parameters.tcp_rates[1] = 960.0f;
-            parameters.tcp_rates[2] = 480.0f;
-            parameters.tcp_rates[3] = 120.0f;
-            parameters.tcp_rates[4] = 30.0f;
-            parameters.irreversible = 1;
-            parameters.tcp_mct = 1;
-        }
-
-        if (comment_text)
-        {
-            free(comment_text);
-        }
-        comment_text = comment_text_in ? strdup(comment_text_in) : nullptr;
-
-        parameters.cp_comment = comment_text ? comment_text : (char*)"no comment";
-        llassert(parameters.cp_comment);
-    }
-
-    ~JPEG2KEncode()
-    {
-        if (encoder)
-        {
-            opj_destroy_codec(encoder);
-        }
-        encoder = nullptr;
-
-        if (image)
-        {
-            opj_image_destroy(image);
-        }
-        image = nullptr;
-
-        if (stream)
-        {
-            opj_stream_destroy(stream);
-        }
-        stream = nullptr;
-
-        if (comment_text)
-        {
-            free(comment_text);
-        }
-        comment_text = nullptr;
-    }
-
-    bool encode(const LLImageRaw& rawImageIn, LLImageJ2C &compressedImageOut)
-    {
-        LLImageDataSharedLock lockIn(&rawImageIn);
-        LLImageDataLock lockOut(&compressedImageOut);
-
-        setImage(rawImageIn);
-
-        encoder = opj_create_compress(OPJ_CODEC_J2K);
-
-        parameters.tcp_mct = (image->numcomps >= 3) ? 1 : 0;
-        parameters.cod_format = OPJ_CODEC_J2K;
-        parameters.prog_order = OPJ_RLCP;
-        parameters.cp_disto_alloc = 1;
-
-        if (!opj_setup_encoder(encoder, &parameters, image))
-        {
-            return false;
-        }
-
-        opj_set_info_handler(encoder, opj_info, this);
-        opj_set_warning_handler(encoder, opj_warn, this);
-        opj_set_error_handler(encoder, opj_error, this);
-
-        U32 tile_count = (rawImageIn.getWidth() >> 6) * (rawImageIn.getHeight() >> 6);
-        U32 data_size_guess = tile_count * TILE_SIZE;
-
-        // will be freed in opj_free_user_data_write
-        buffer = (U8*)ll_aligned_malloc_16(data_size_guess);
-        size = data_size_guess;
-        offset = 0;
-
-        memset(buffer, 0, data_size_guess);
-
-        if (stream)
-        {
-            opj_stream_destroy(stream);
-        }
-
-        stream = opj_stream_create(data_size_guess, false);
-        if (!stream)
-        {
-            return false;
-        }
-
-        opj_stream_set_user_data(stream, this, opj_free_user_data_write);
-        opj_stream_set_user_data_length(stream, data_size_guess);
-        opj_stream_set_read_function(stream, opj_read);
-        opj_stream_set_write_function(stream, opj_write);
-        opj_stream_set_skip_function(stream, opj_skip);
-        opj_stream_set_seek_function(stream, opj_seek);
-
-        OPJ_BOOL started = opj_start_compress(encoder, image, stream);
-
-        if (!started)
-        {
-            return false;
-        }
-
-        if (!opj_encode(encoder, stream))
-        {
-            return false;
-        }
-
-        OPJ_BOOL encoded = opj_end_compress(encoder, stream);
-
-        // if we successfully encoded, then stream out the compressed data...
-        if (encoded)
-        {
-            // "append" (set) the data we "streamed" (memcopied) for writing to the formatted image
-            // with side-effect of setting the actually encoded size  to same
-            compressedImageOut.allocateData(offset);
-            memcpy(compressedImageOut.getData(), buffer, offset);
-            compressedImageOut.updateData(); // update width, height etc from header
-        }
-        return encoded;
-    }
-
-    void setImage(const LLImageRaw& raw)
-    {
-        opj_image_cmptparm_t cmptparm[MAX_ENCODED_DISCARD_LEVELS];
-        memset(&cmptparm[0], 0, MAX_ENCODED_DISCARD_LEVELS * sizeof(opj_image_cmptparm_t));
-
-        S32 numcomps = raw.getComponents();
-        S32 width = raw.getWidth();
-        S32 height = raw.getHeight();
-
-        for (S32 c = 0; c < numcomps; c++)
-        {
-            cmptparm[c].prec = 8;
-            cmptparm[c].bpp = 8;
-            cmptparm[c].sgnd = 0;
-            cmptparm[c].dx = parameters.subsampling_dx;
-            cmptparm[c].dy = parameters.subsampling_dy;
-            cmptparm[c].w = width;
-            cmptparm[c].h = height;
-        }
-
-        image = opj_image_create(numcomps, &cmptparm[0], OPJ_CLRSPC_SRGB);
-
-        image->x1 = width;
-        image->y1 = height;
-
-        const U8 *src_datap = raw.getData();
-
-        S32 i = 0;
-        for (S32 y = height - 1; y >= 0; y--)
-        {
-            for (S32 x = 0; x < width; x++)
-            {
-                const U8 *pixel = src_datap + (y*width + x) * numcomps;
-                for (S32 c = 0; c < numcomps; c++)
-                {
-                    image->comps[c].data[i] = *pixel;
-                    pixel++;
-                }
-                i++;
-            }
-        }
-
-        // This likely works, but there seems to be an issue openjpeg side
-        // check over after gixing that.
-
-        // De-interleave to component plane data
-        /*
-        switch (numcomps)
-        {
-        case 0:
-        default:
-            break;
-
-        case 1:
-        {
-            U32 rBitDepth = image->comps[0].bpp;
-            U32 bytesPerPixel = rBitDepth >> 3;
-            memcpy(image->comps[0].data, src, width * height * bytesPerPixel);
-        }
-        break;
-
-        case 2:
-        {
-            U32 rBitDepth = image->comps[0].bpp;
-            U32 gBitDepth = image->comps[1].bpp;
-            U32 totalBitDepth = rBitDepth + gBitDepth;
-            U32 bytesPerPixel = totalBitDepth >> 3;
-            U32 stride = width * bytesPerPixel;
-            U32 offset = 0;
-            for (S32 y = height - 1; y >= 0; y--)
-            {
-                const U8* component = src + (y * stride);
-                for (S32 x = 0; x < width; x++)
-                {
-                    image->comps[0].data[offset] = *component++;
-                    image->comps[1].data[offset] = *component++;
-                    offset++;
-                }
-            }
-        }
-        break;
-
-        case 3:
-        {
-            U32 rBitDepth = image->comps[0].bpp;
-            U32 gBitDepth = image->comps[1].bpp;
-            U32 bBitDepth = image->comps[2].bpp;
-            U32 totalBitDepth = rBitDepth + gBitDepth + bBitDepth;
-            U32 bytesPerPixel = totalBitDepth >> 3;
-            U32 stride = width * bytesPerPixel;
-            U32 offset = 0;
-            for (S32 y = height - 1; y >= 0; y--)
-            {
-                const U8* component = src + (y * stride);
-                for (S32 x = 0; x < width; x++)
-                {
-                    image->comps[0].data[offset] = *component++;
-                    image->comps[1].data[offset] = *component++;
-                    image->comps[2].data[offset] = *component++;
-                    offset++;
-                }
-            }
-        }
-        break;
-
-
-        case 4:
-        {
-            U32 rBitDepth = image->comps[0].bpp;
-            U32 gBitDepth = image->comps[1].bpp;
-            U32 bBitDepth = image->comps[2].bpp;
-            U32 aBitDepth = image->comps[3].bpp;
-
-            U32 totalBitDepth = rBitDepth + gBitDepth + bBitDepth + aBitDepth;
-            U32 bytesPerPixel = totalBitDepth >> 3;
-
-            U32 stride = width * bytesPerPixel;
-            U32 offset = 0;
-            for (S32 y = height - 1; y >= 0; y--)
-            {
-                const U8* component = src + (y * stride);
-                for (S32 x = 0; x < width; x++)
-                {
-                    image->comps[0].data[offset] = *component++;
-                    image->comps[1].data[offset] = *component++;
-                    image->comps[2].data[offset] = *component++;
-                    image->comps[3].data[offset] = *component++;
-                    offset++;
-                }
-            }
-        }
-        break;
-        }*/
-    }
-
-    opj_image_t* getImage() { return image; }
-
-private:
-    opj_cparameters_t   parameters;
-    opj_event_mgr_t     event_mgr;
-    opj_image_t*        image = nullptr;
-    opj_codec_t*        encoder = nullptr;
-    opj_stream_t*       stream = nullptr;
-    char*               comment_text = nullptr;
-};
-
-
-LLImageJ2COJ::LLImageJ2COJ()
-	: LLImageJ2CImpl()
-{
-}
-
-
-LLImageJ2COJ::~LLImageJ2COJ()
-{
-}
-
-bool LLImageJ2COJ::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level, int* region)
-{
-    base.mDiscardLevel = discard_level;
-	return false;
-}
-
-bool LLImageJ2COJ::initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size, int precincts_size, int levels)
-{
-    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
-	// No specific implementation for this method in the OpenJpeg case
-	return false;
-}
-
-bool LLImageJ2COJ::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count)
-{
-    LLImageDataLock lockIn(&base);
-    LLImageDataLock lockOut(&raw_image);
-
-    JPEG2KDecode decoder(0);
-
-    U32 image_channels = 0;
-    S32 data_size = base.getDataSize();
-    S32 max_bytes = (base.getMaxBytes() ? base.getMaxBytes() : data_size);
-    bool decoded = decoder.decode(base.getData(), max_bytes, &image_channels, base.mDiscardLevel);
-
-    // set correct channel count early so failed decodes don't miss it...
-    S32 channels = (S32)image_channels - first_channel;
-    channels = llmin(channels, max_channel_count);
-
-    if (!decoded)
-    {
-        // reset the channel count if necessary
-        if (raw_image.getComponents() != channels)
-        {
-            raw_image.resize(raw_image.getWidth(), raw_image.getHeight(), S8(channels));
-        }
-
-        LL_DEBUGS("Texture") << "ERROR -> decodeImpl: failed to decode image!" << LL_ENDL;
-        return true; // done
-    }
-
-    opj_image_t *image = decoder.getImage();
-
-    // Component buffers are allocated in an image width by height buffer.
-    // The image placed in that buffer is ceil(width/2^factor) by
-    // ceil(height/2^factor) and if the factor isn't zero it will be at the
-    // top left of the buffer with black filled in the rest of the pixels.
-    // It is integer math so the formula is written in ceildivpo2.
-    // (Assuming all the components have the same width, height and
-    // factor.)
-    U32 comp_width = image->comps[0].w; // leave this unshifted by 'f' discard factor, the strides are always for the full buffer width
-    U32 f = image->comps[0].factor;
-
-    // do size the texture to the mem we'll acrually use...
-    U32 width = image->comps[0].w;
-    U32 height = image->comps[0].h;
-
-    raw_image.resize(U16(width), U16(height), S8(channels));
-
-    U8 *rawp = raw_image.getData();
-
-    // first_channel is what channel to start copying from
-    // dest is what channel to copy to.  first_channel comes from the
-    // argument, dest always starts writing at channel zero.
-    for (S32 comp = first_channel, dest = 0; comp < first_channel + channels; comp++, dest++)
-    {
-        llassert(image->comps[comp].data);
-        if (image->comps[comp].data)
-        {
-            S32 offset = dest;
-            for (S32 y = (height - 1); y >= 0; y--)
-            {
-                for (S32 x = 0; x < width; x++)
-                {
-                    rawp[offset] = image->comps[comp].data[y*comp_width + x];
-                    offset += channels;
-                }
-            }
-        }
-        else // Some rare OpenJPEG versions have this bug.
-        {
-            LL_DEBUGS("Texture") << "ERROR -> decodeImpl: failed! (OpenJPEG bug)" << LL_ENDL;
-        }
-    }
-
-    base.setDiscardLevel(f);
-
-    return true; // done
-}
-
-
-bool LLImageJ2COJ::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time, bool reversible)
-{
-    JPEG2KEncode encode(comment_text, reversible);
-    bool encoded = encode.encode(raw_image, base);
-    if (encoded)
-    {
-        LL_WARNS() << "Openjpeg encoding implementation isn't complete, returning false" << LL_ENDL;
-    }
-    return encoded;
-    //return false;
-}
-
-bool LLImageJ2COJ::getMetadata(LLImageJ2C &base)
-{
-    LLImageDataLock lock(&base);
-
-    JPEG2KDecode decode(0);
-
-    S32 width = 0;
-    S32 height = 0;
-    S32 components = 0;
-    S32 discard_level = 0;
-
-    U32 dataSize = base.getDataSize();
-    U8* data = base.getData();
-    bool header_read = decode.readHeader(data, dataSize, width, height, components, discard_level);
-    if (!header_read)
-    {
-        return false;
-    }
-
-    base.mDiscardLevel = discard_level;
-    base.setSize(width, height, components);
-    return true;
-}
+/**

+ * @file llimagej2coj.cpp

+ * @brief This is an implementation of JPEG2000 encode/decode using OpenJPEG.

+ *

+ * $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"

+#include "llimagej2coj.h"

+

+// this is defined so that we get static linking.

+#include "openjpeg.h"

+#include "event.h"

+#include "cio.h"

+

+#define MAX_ENCODED_DISCARD_LEVELS 5

+

+// Factory function: see declaration in llimagej2c.cpp

+LLImageJ2CImpl* fallbackCreateLLImageJ2CImpl()

+{

+    return new LLImageJ2COJ();

+}

+

+std::string LLImageJ2COJ::getEngineInfo() const

+{

+#ifdef OPENJPEG_VERSION

+    return std::string("OpenJPEG: " OPENJPEG_VERSION ", Runtime: ")

+        + opj_version();

+#else

+    return std::string("OpenJPEG runtime: ") + opj_version();

+#endif

+}

+

+// Return string from message, eliminating final \n if present

+static std::string chomp(const char* msg)

+{

+    // stomp trailing \n

+    std::string message = msg;

+    if (!message.empty())

+    {

+        size_t last = message.size() - 1;

+        if (message[last] == '\n')

+        {

+            message.resize(last);

+        }

+}

+    return message;

+}

+

+/**

+sample error callback expecting a LLFILE* client object

+*/

+void error_callback(const char* msg, void*)

+{

+    LL_DEBUGS() << "LLImageJ2COJ: " << chomp(msg) << LL_ENDL;

+}

+/**

+sample warning callback expecting a LLFILE* client object

+*/

+void warning_callback(const char* msg, void*)

+{

+    LL_DEBUGS() << "LLImageJ2COJ: " << chomp(msg) << LL_ENDL;

+}

+/**

+sample debug callback expecting no client object

+*/

+void info_callback(const char* msg, void*)

+{

+    LL_DEBUGS() << "LLImageJ2COJ: " << chomp(msg) << LL_ENDL;

+}

+

+// Divide a by 2 to the power of b and round upwards

+int ceildivpow2(int a, int b)

+{

+    return (a + (1 << b) - 1) >> b;

+}

+

+class JPEG2KBase

+{

+public:

+    JPEG2KBase() {}

+

+    U8*        buffer = nullptr;

+    OPJ_SIZE_T size = 0;

+    OPJ_OFF_T  offset = 0;

+};

+

+#define WANT_VERBOSE_OPJ_SPAM LL_DEBUG

+

+static void opj_info(const char* msg, void* user_data)

+{

+    llassert(user_data);

+#if WANT_VERBOSE_OPJ_SPAM

+    LL_INFOS("OpenJPEG") << msg << LL_ENDL;

+#endif

+}

+

+static void opj_warn(const char* msg, void* user_data)

+{

+    llassert(user_data);

+#if WANT_VERBOSE_OPJ_SPAM

+    LL_WARNS("OpenJPEG") << msg << LL_ENDL;

+#endif

+}

+

+static void opj_error(const char* msg, void* user_data)

+{

+    llassert(user_data);

+#if WANT_VERBOSE_OPJ_SPAM

+    LL_WARNS("OpenJPEG") << msg << LL_ENDL;

+#endif

+}

+

+static OPJ_SIZE_T opj_read(void * buffer, OPJ_SIZE_T bytes, void* user_data)

+{

+    llassert(user_data);

+    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);

+    OPJ_SIZE_T remainder = (jpeg_codec->size - jpeg_codec->offset);

+    if (remainder <= 0)

+    {

+        jpeg_codec->offset = jpeg_codec->size;

+        // Indicate end of stream (hacky?)

+        return (OPJ_OFF_T)-1;

+    }

+    OPJ_SIZE_T to_read = llclamp(U32(bytes), U32(0), U32(remainder));

+    memcpy(buffer, jpeg_codec->buffer + jpeg_codec->offset, to_read);

+    jpeg_codec->offset += to_read;

+    return to_read;

+}

+

+static OPJ_SIZE_T opj_write(void * buffer, OPJ_SIZE_T bytes, void* user_data)

+{

+    llassert(user_data);

+    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);

+    OPJ_SIZE_T remainder = jpeg_codec->size - jpeg_codec->offset;

+    if (remainder < bytes)

+    {

+        OPJ_SIZE_T new_size = jpeg_codec->size + (bytes - remainder);

+        U8* new_buffer = (U8*)ll_aligned_malloc_16(new_size);

+        memcpy(new_buffer, jpeg_codec->buffer, jpeg_codec->offset);

+        U8* old_buffer = jpeg_codec->buffer;

+        jpeg_codec->buffer = new_buffer;

+        ll_aligned_free_16(old_buffer);

+        jpeg_codec->size = new_size;

+    }

+    memcpy(jpeg_codec->buffer + jpeg_codec->offset, buffer, bytes);

+    jpeg_codec->offset += bytes;

+    return bytes;

+}

+

+static OPJ_OFF_T opj_skip(OPJ_OFF_T bytes, void* user_data)

+{

+    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);

+    jpeg_codec->offset += bytes;

+

+    if (jpeg_codec->offset > jpeg_codec->size)

+    {

+        jpeg_codec->offset = jpeg_codec->size;

+        // Indicate end of stream

+        return (OPJ_OFF_T)-1;

+    }

+

+    if (jpeg_codec->offset < 0)

+    {

+        // Shouldn't be possible?

+        jpeg_codec->offset = 0;

+        return (OPJ_OFF_T)-1;

+    }

+

+    return bytes;

+}

+

+static OPJ_BOOL opj_seek(OPJ_OFF_T bytes, void * user_data)

+{

+    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);

+    jpeg_codec->offset = bytes;

+    jpeg_codec->offset = llclamp(U32(jpeg_codec->offset), U32(0), U32(jpeg_codec->size));

+    return OPJ_TRUE;

+}

+

+static void opj_free_user_data(void * user_data)

+{

+    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);

+    // Don't free, data is managed externally

+    jpeg_codec->buffer = nullptr;

+    jpeg_codec->size = 0;

+    jpeg_codec->offset = 0;

+}

+

+static void opj_free_user_data_write(void * user_data)

+{

+    JPEG2KBase* jpeg_codec = static_cast<JPEG2KBase*>(user_data);

+    // Free, data was allocated here

+    ll_aligned_free_16(jpeg_codec->buffer);

+    jpeg_codec->buffer = nullptr;

+    jpeg_codec->size = 0;

+    jpeg_codec->offset = 0;

+}

+

+class JPEG2KDecode : public JPEG2KBase

+{

+public:

+

+    JPEG2KDecode(S8 discardLevel)

+    {

+        memset(&event_mgr, 0, sizeof(opj_event_mgr_t));

+        memset(&parameters, 0, sizeof(opj_dparameters_t));

+        event_mgr.error_handler = error_callback;

+        event_mgr.warning_handler = warning_callback;

+        event_mgr.info_handler = info_callback;

+        opj_set_default_decoder_parameters(&parameters);

+        parameters.cp_reduce = discardLevel;

+    }

+

+    ~JPEG2KDecode()

+    {

+        if (decoder)

+        {

+            opj_destroy_codec(decoder);

+        }

+        decoder = nullptr;

+

+        if (image)

+        {

+            opj_image_destroy(image);

+        }

+        image = nullptr;

+

+        if (stream)

+        {

+            opj_stream_destroy(stream);

+        }

+        stream = nullptr;

+

+        if (codestream_info)

+        {

+            opj_destroy_cstr_info(&codestream_info);

+        }

+        codestream_info = nullptr;

+    }

+

+    bool readHeader(

+        U8* data,

+        U32 dataSize,

+        S32& widthOut,

+        S32& heightOut,

+        S32& components,

+        S32& discard_level)

+    {

+        parameters.flags |= OPJ_DPARAMETERS_DUMP_FLAG;

+

+        decoder = opj_create_decompress(OPJ_CODEC_J2K);

+

+        if (!opj_setup_decoder(decoder, &parameters))

+        {

+            return false;

+        }

+

+        if (stream)

+        {

+            opj_stream_destroy(stream);

+        }

+

+        stream = opj_stream_create(dataSize, true);

+        if (!stream)

+        {

+            return false;

+        }

+

+        opj_stream_set_user_data(stream, this, opj_free_user_data);

+        opj_stream_set_user_data_length(stream, dataSize);

+        opj_stream_set_read_function(stream, opj_read);

+        opj_stream_set_write_function(stream, opj_write);

+        opj_stream_set_skip_function(stream, opj_skip);

+        opj_stream_set_seek_function(stream, opj_seek);

+

+        buffer = data;

+        size = dataSize;

+        offset = 0;

+

+        // enable decoding partially loaded images

+        opj_decoder_set_strict_mode(decoder, OPJ_FALSE);

+

+        /* Read the main header of the codestream and if necessary the JP2 boxes*/

+        if (!opj_read_header((opj_stream_t*)stream, decoder, &image))

+        {

+            return false;

+        }

+

+        codestream_info = opj_get_cstr_info(decoder);

+

+        if (!codestream_info)

+        {

+            return false;

+        }

+

+        U32 tileDimX = codestream_info->tdx;

+        U32 tileDimY = codestream_info->tdy;

+        U32 tilesW = codestream_info->tw;

+        U32 tilesH = codestream_info->th;

+

+        widthOut = S32(tilesW * tileDimX);

+        heightOut = S32(tilesH * tileDimY);

+        components = codestream_info->nbcomps;

+

+        discard_level = 0;

+        while (tilesW > 1 && tilesH > 1 && discard_level < MAX_DISCARD_LEVEL)

+        {

+            discard_level++;

+            tilesW >>= 1;

+            tilesH >>= 1;

+        }

+

+        return true;

+    }

+

+    bool decode(U8* data, U32 dataSize, U32* channels, U8 discard_level)

+    {

+        parameters.flags &= ~OPJ_DPARAMETERS_DUMP_FLAG;

+

+        decoder = opj_create_decompress(OPJ_CODEC_J2K);

+        opj_setup_decoder(decoder, &parameters);

+

+        opj_set_info_handler(decoder, opj_info, this);

+        opj_set_warning_handler(decoder, opj_warn, this);

+        opj_set_error_handler(decoder, opj_error, this);

+

+        if (stream)

+        {

+            opj_stream_destroy(stream);

+        }

+

+        stream = opj_stream_create(dataSize, true);

+        if (!stream)

+        {

+            return false;

+        }

+

+        opj_stream_set_user_data(stream, this, opj_free_user_data);

+        opj_stream_set_user_data_length(stream, dataSize);

+        opj_stream_set_read_function(stream, opj_read);

+        opj_stream_set_write_function(stream, opj_write);

+        opj_stream_set_skip_function(stream, opj_skip);

+        opj_stream_set_seek_function(stream, opj_seek);

+

+        buffer = data;

+        size = dataSize;

+        offset = 0;

+

+        if (image)

+        {

+            opj_image_destroy(image);

+            image = nullptr;

+        }

+

+        // needs to happen before opj_read_header and opj_decode...

+        opj_set_decoded_resolution_factor(decoder, discard_level);

+

+        // enable decoding partially loaded images

+        opj_decoder_set_strict_mode(decoder, OPJ_FALSE);

+

+        if (!opj_read_header(stream, decoder, &image))

+        {

+            return false;

+        }

+

+        // needs to happen before decode which may fail

+        if (channels)

+        {

+            *channels = image->numcomps;

+        }

+

+        OPJ_BOOL decoded = opj_decode(decoder, stream, image);

+

+        // count was zero.  The latter is just a sanity check before we

+        // dereference the array.

+        if (!decoded || !image || !image->numcomps)

+        {

+            opj_end_decompress(decoder, stream);

+            return false;

+        }

+

+        opj_end_decompress(decoder, stream);

+

+        return true;

+    }

+

+    opj_image_t* getImage() { return image; }

+

+private:

+    opj_dparameters_t         parameters;

+    opj_event_mgr_t           event_mgr;

+    opj_image_t*              image = nullptr;

+    opj_codec_t*              decoder = nullptr;

+    opj_stream_t*             stream = nullptr;

+    opj_codestream_info_v2_t* codestream_info = nullptr;

+};

+

+class JPEG2KEncode : public JPEG2KBase

+{

+public:

+    const OPJ_UINT32 TILE_SIZE = 64 * 64 * 3;

+

+    JPEG2KEncode(const char* comment_text_in, bool reversible)

+    {

+        memset(&parameters, 0, sizeof(opj_cparameters_t));

+        memset(&event_mgr, 0, sizeof(opj_event_mgr_t));

+        event_mgr.error_handler = error_callback;

+        event_mgr.warning_handler = warning_callback;

+        event_mgr.info_handler = info_callback;

+

+        opj_set_default_encoder_parameters(&parameters);

+        parameters.cod_format = OPJ_CODEC_J2K;

+        parameters.cp_disto_alloc = 1;

+        parameters.max_cs_size = (1 << 15);

+

+        if (reversible)

+        {

+            parameters.tcp_numlayers = 1;

+            parameters.tcp_rates[0] = 1.0f;

+        }

+        else

+        {

+            parameters.tcp_numlayers = 5;

+            parameters.tcp_rates[0] = 1920.0f;

+            parameters.tcp_rates[1] = 960.0f;

+            parameters.tcp_rates[2] = 480.0f;

+            parameters.tcp_rates[3] = 120.0f;

+            parameters.tcp_rates[4] = 30.0f;

+            parameters.irreversible = 1;

+            parameters.tcp_mct = 1;

+        }

+

+        if (comment_text)

+        {

+            free(comment_text);

+        }

+        comment_text = comment_text_in ? strdup(comment_text_in) : nullptr;

+

+        parameters.cp_comment = comment_text ? comment_text : (char*)"no comment";

+        llassert(parameters.cp_comment);

+    }

+

+    ~JPEG2KEncode()

+    {

+        if (encoder)

+        {

+            opj_destroy_codec(encoder);

+        }

+        encoder = nullptr;

+

+        if (image)

+        {

+            opj_image_destroy(image);

+        }

+        image = nullptr;

+

+        if (stream)

+        {

+            opj_stream_destroy(stream);

+        }

+        stream = nullptr;

+

+        if (comment_text)

+        {

+            free(comment_text);

+        }

+        comment_text = nullptr;

+    }

+

+    bool encode(const LLImageRaw& rawImageIn, LLImageJ2C &compressedImageOut)

+    {

+        LLImageDataSharedLock lockIn(&rawImageIn);

+        LLImageDataLock lockOut(&compressedImageOut);

+

+        setImage(rawImageIn);

+

+        encoder = opj_create_compress(OPJ_CODEC_J2K);

+

+        parameters.tcp_mct = (image->numcomps >= 3) ? 1 : 0;

+        parameters.cod_format = OPJ_CODEC_J2K;

+        parameters.prog_order = OPJ_RLCP;

+        parameters.cp_disto_alloc = 1;

+

+        if (!opj_setup_encoder(encoder, &parameters, image))

+        {

+            return false;

+        }

+

+        opj_set_info_handler(encoder, opj_info, this);

+        opj_set_warning_handler(encoder, opj_warn, this);

+        opj_set_error_handler(encoder, opj_error, this);

+

+        U32 tile_count = (rawImageIn.getWidth() >> 6) * (rawImageIn.getHeight() >> 6);

+        U32 data_size_guess = tile_count * TILE_SIZE;

+

+        // will be freed in opj_free_user_data_write

+        buffer = (U8*)ll_aligned_malloc_16(data_size_guess);

+        size = data_size_guess;

+        offset = 0;

+

+        memset(buffer, 0, data_size_guess);

+

+        if (stream)

+        {

+            opj_stream_destroy(stream);

+        }

+

+        stream = opj_stream_create(data_size_guess, false);

+        if (!stream)

+        {

+            return false;

+        }

+

+        opj_stream_set_user_data(stream, this, opj_free_user_data_write);

+        opj_stream_set_user_data_length(stream, data_size_guess);

+        opj_stream_set_read_function(stream, opj_read);

+        opj_stream_set_write_function(stream, opj_write);

+        opj_stream_set_skip_function(stream, opj_skip);

+        opj_stream_set_seek_function(stream, opj_seek);

+

+        OPJ_BOOL started = opj_start_compress(encoder, image, stream);

+

+        if (!started)

+        {

+            return false;

+        }

+

+        if (!opj_encode(encoder, stream))

+        {

+            return false;

+        }

+

+        OPJ_BOOL encoded = opj_end_compress(encoder, stream);

+

+        // if we successfully encoded, then stream out the compressed data...

+        if (encoded)

+        {

+            // "append" (set) the data we "streamed" (memcopied) for writing to the formatted image

+            // with side-effect of setting the actually encoded size  to same

+            compressedImageOut.allocateData(offset);

+            memcpy(compressedImageOut.getData(), buffer, offset);

+            compressedImageOut.updateData(); // update width, height etc from header

+        }

+        return encoded;

+    }

+

+    void setImage(const LLImageRaw& raw)

+    {

+        opj_image_cmptparm_t cmptparm[MAX_ENCODED_DISCARD_LEVELS];

+        memset(&cmptparm[0], 0, MAX_ENCODED_DISCARD_LEVELS * sizeof(opj_image_cmptparm_t));

+

+        S32 numcomps = raw.getComponents();

+        S32 width = raw.getWidth();

+        S32 height = raw.getHeight();

+

+        for (S32 c = 0; c < numcomps; c++)

+        {

+            cmptparm[c].prec = 8;

+            cmptparm[c].bpp = 8;

+            cmptparm[c].sgnd = 0;

+            cmptparm[c].dx = parameters.subsampling_dx;

+            cmptparm[c].dy = parameters.subsampling_dy;

+            cmptparm[c].w = width;

+            cmptparm[c].h = height;

+        }

+

+        image = opj_image_create(numcomps, &cmptparm[0], OPJ_CLRSPC_SRGB);

+

+        image->x1 = width;

+        image->y1 = height;

+

+        const U8 *src_datap = raw.getData();

+

+        S32 i = 0;

+        for (S32 y = height - 1; y >= 0; y--)

+        {

+            for (S32 x = 0; x < width; x++)

+            {

+                const U8 *pixel = src_datap + (y*width + x) * numcomps;

+                for (S32 c = 0; c < numcomps; c++)

+                {

+                    image->comps[c].data[i] = *pixel;

+                    pixel++;

+                }

+                i++;

+            }

+        }

+

+        // This likely works, but there seems to be an issue openjpeg side

+        // check over after gixing that.

+

+        // De-interleave to component plane data

+        /*

+        switch (numcomps)

+        {

+        case 0:

+        default:

+            break;

+

+        case 1:

+        {

+            U32 rBitDepth = image->comps[0].bpp;

+            U32 bytesPerPixel = rBitDepth >> 3;

+            memcpy(image->comps[0].data, src, width * height * bytesPerPixel);

+        }

+        break;

+

+        case 2:

+        {

+            U32 rBitDepth = image->comps[0].bpp;

+            U32 gBitDepth = image->comps[1].bpp;

+            U32 totalBitDepth = rBitDepth + gBitDepth;

+            U32 bytesPerPixel = totalBitDepth >> 3;

+            U32 stride = width * bytesPerPixel;

+            U32 offset = 0;

+            for (S32 y = height - 1; y >= 0; y--)

+            {

+                const U8* component = src + (y * stride);

+                for (S32 x = 0; x < width; x++)

+                {

+                    image->comps[0].data[offset] = *component++;

+                    image->comps[1].data[offset] = *component++;

+                    offset++;

+                }

+            }

+        }

+        break;

+

+        case 3:

+        {

+            U32 rBitDepth = image->comps[0].bpp;

+            U32 gBitDepth = image->comps[1].bpp;

+            U32 bBitDepth = image->comps[2].bpp;

+            U32 totalBitDepth = rBitDepth + gBitDepth + bBitDepth;

+            U32 bytesPerPixel = totalBitDepth >> 3;

+            U32 stride = width * bytesPerPixel;

+            U32 offset = 0;

+            for (S32 y = height - 1; y >= 0; y--)

+            {

+                const U8* component = src + (y * stride);

+                for (S32 x = 0; x < width; x++)

+                {

+                    image->comps[0].data[offset] = *component++;

+                    image->comps[1].data[offset] = *component++;

+                    image->comps[2].data[offset] = *component++;

+                    offset++;

+                }

+            }

+        }

+        break;

+

+

+        case 4:

+        {

+            U32 rBitDepth = image->comps[0].bpp;

+            U32 gBitDepth = image->comps[1].bpp;

+            U32 bBitDepth = image->comps[2].bpp;

+            U32 aBitDepth = image->comps[3].bpp;

+

+            U32 totalBitDepth = rBitDepth + gBitDepth + bBitDepth + aBitDepth;

+            U32 bytesPerPixel = totalBitDepth >> 3;

+

+            U32 stride = width * bytesPerPixel;

+            U32 offset = 0;

+            for (S32 y = height - 1; y >= 0; y--)

+            {

+                const U8* component = src + (y * stride);

+                for (S32 x = 0; x < width; x++)

+                {

+                    image->comps[0].data[offset] = *component++;

+                    image->comps[1].data[offset] = *component++;

+                    image->comps[2].data[offset] = *component++;

+                    image->comps[3].data[offset] = *component++;

+                    offset++;

+                }

+            }

+        }

+        break;

+        }*/

+    }

+

+    opj_image_t* getImage() { return image; }

+

+private:

+    opj_cparameters_t   parameters;

+    opj_event_mgr_t     event_mgr;

+    opj_image_t*        image = nullptr;

+    opj_codec_t*        encoder = nullptr;

+    opj_stream_t*       stream = nullptr;

+    char*               comment_text = nullptr;

+};

+

+

+LLImageJ2COJ::LLImageJ2COJ()

+    : LLImageJ2CImpl()

+{

+}

+

+

+LLImageJ2COJ::~LLImageJ2COJ()

+{

+}

+

+bool LLImageJ2COJ::initDecode(LLImageJ2C &base, LLImageRaw &raw_image, int discard_level, int* region)

+{

+    base.mDiscardLevel = discard_level;

+    return false;

+}

+

+bool LLImageJ2COJ::initEncode(LLImageJ2C &base, LLImageRaw &raw_image, int blocks_size, int precincts_size, int levels)

+{

+    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;

+    // No specific implementation for this method in the OpenJpeg case

+    return false;

+}

+

+bool LLImageJ2COJ::decodeImpl(LLImageJ2C &base, LLImageRaw &raw_image, F32 decode_time, S32 first_channel, S32 max_channel_count)

+{

+    LLImageDataLock lockIn(&base);

+    LLImageDataLock lockOut(&raw_image);

+

+    JPEG2KDecode decoder(0);

+

+    U32 image_channels = 0;

+    S32 data_size = base.getDataSize();

+    S32 max_bytes = (base.getMaxBytes() ? base.getMaxBytes() : data_size);

+    bool decoded = decoder.decode(base.getData(), max_bytes, &image_channels, base.mDiscardLevel);

+

+    // set correct channel count early so failed decodes don't miss it...

+    S32 channels = (S32)image_channels - first_channel;

+    channels = llmin(channels, max_channel_count);

+

+    if (!decoded)

+    {

+        // reset the channel count if necessary

+        if (raw_image.getComponents() != channels)

+        {

+            raw_image.resize(raw_image.getWidth(), raw_image.getHeight(), S8(channels));

+        }

+

+        LL_DEBUGS("Texture") << "ERROR -> decodeImpl: failed to decode image!" << LL_ENDL;

+        return true; // done

+    }

+

+    opj_image_t *image = decoder.getImage();

+

+    // Component buffers are allocated in an image width by height buffer.

+    // The image placed in that buffer is ceil(width/2^factor) by

+    // ceil(height/2^factor) and if the factor isn't zero it will be at the

+    // top left of the buffer with black filled in the rest of the pixels.

+    // It is integer math so the formula is written in ceildivpo2.

+    // (Assuming all the components have the same width, height and

+    // factor.)

+    U32 comp_width = image->comps[0].w; // leave this unshifted by 'f' discard factor, the strides are always for the full buffer width

+    U32 f = image->comps[0].factor;

+

+    // do size the texture to the mem we'll acrually use...

+    U32 width = image->comps[0].w;

+    U32 height = image->comps[0].h;

+

+    raw_image.resize(U16(width), U16(height), S8(channels));

+

+    U8 *rawp = raw_image.getData();

+

+    // first_channel is what channel to start copying from

+    // dest is what channel to copy to.  first_channel comes from the

+    // argument, dest always starts writing at channel zero.

+    for (S32 comp = first_channel, dest = 0; comp < first_channel + channels; comp++, dest++)

+    {

+        llassert(image->comps[comp].data);

+        if (image->comps[comp].data)

+        {

+            S32 offset = dest;

+            for (S32 y = (height - 1); y >= 0; y--)

+            {

+                for (S32 x = 0; x < width; x++)

+                {

+                    rawp[offset] = image->comps[comp].data[y*comp_width + x];

+                    offset += channels;

+                }

+            }

+        }

+        else // Some rare OpenJPEG versions have this bug.

+        {

+            LL_DEBUGS("Texture") << "ERROR -> decodeImpl: failed! (OpenJPEG bug)" << LL_ENDL;

+        }

+    }

+

+    base.setDiscardLevel(f);

+

+    return true; // done

+}

+

+

+bool LLImageJ2COJ::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time, bool reversible)

+{

+    JPEG2KEncode encode(comment_text, reversible);

+    bool encoded = encode.encode(raw_image, base);

+    if (encoded)

+    {

+        LL_WARNS() << "Openjpeg encoding implementation isn't complete, returning false" << LL_ENDL;

+    }

+    return encoded;

+    //return false;

+}

+

+bool LLImageJ2COJ::getMetadata(LLImageJ2C &base)

+{

+    LLImageDataLock lock(&base);

+

+    JPEG2KDecode decode(0);

+

+    S32 width = 0;

+    S32 height = 0;

+    S32 components = 0;

+    S32 discard_level = 0;

+

+    U32 dataSize = base.getDataSize();

+    U8* data = base.getData();

+    bool header_read = decode.readHeader(data, dataSize, width, height, components, discard_level);

+    if (!header_read)

+    {

+        return false;

+    }

+

+    base.mDiscardLevel = discard_level;

+    base.setSize(width, height, components);

+    return true;

+}

diff --git a/indra/llimagej2coj/llimagej2coj.h b/indra/llimagej2coj/llimagej2coj.h
index 5c6193944e..498502451a 100644
--- a/indra/llimagej2coj/llimagej2coj.h
+++ b/indra/llimagej2coj/llimagej2coj.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llimagej2coj.h
  * @brief This is an implementation of JPEG2000 encode/decode using OpenJPEG.
  *
  * $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$
  */
@@ -30,17 +30,17 @@
 #include "llimagej2c.h"
 
 class LLImageJ2COJ : public LLImageJ2CImpl
-{	
+{
 public:
-	LLImageJ2COJ();
-	virtual ~LLImageJ2COJ();
+    LLImageJ2COJ();
+    virtual ~LLImageJ2COJ();
 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 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;
 };