1 files changed, 75 insertions, 208 deletions

diff --git a/linden/indra/llimage/llimage.cpp b/linden/indra/llimage/llimage.cpp
index acd6aef..eb4ff46 100644
--- a/linden/indra/llimage/llimage.cpp
+++ b/linden/indra/llimage/llimage.cpp
@@ -36,7 +36,7 @@
 #include "llmath.h"
 #include "stdtypes.h"
 #include "v4coloru.h"
-#include "llmemory.h"
+#include "llmemtype.h"
 
 #include "llimage.h"
 #include "llimagebmp.h"
@@ -133,7 +133,7 @@ U8* LLImageBase::allocateData(S32 size)
                         llerrs << llformat("LLImageBase::allocateData called with bad dimentions: %dx%dx%d",mWidth,mHeight,mComponents) << llendl;
                 }
         }
-        else if ((size <= 0 || size > 4096*4096*16) && sSizeOverride == FALSE)
+        else if (size <= 0 || (size > 4096*4096*16 && sSizeOverride == FALSE))
         {
                 llerrs << "LLImageBase::allocateData: bad size: " << size << llendl;
         }
@@ -167,7 +167,7 @@ U8* LLImageBase::reallocateData(S32 size)
         if (mData)
         {
                 S32 bytes = llmin(mDataSize, size);
-                memcpy(new_datap, mData, bytes);
+                memcpy(new_datap, mData, bytes);        /* Flawfinder: ignore */
                 delete[] mData;
         }
         mData = new_datap;
@@ -216,7 +216,8 @@ LLImageRaw::LLImageRaw(U8 *data, U16 width, U16 height, S8 components)
         : LLImageBase()
 {
         mMemType = LLMemType::MTYPE_IMAGERAW;
-        copyData(data, width, height, components);
+        allocateDataSize(width, height, components);
+        memcpy(getData(), data, width*height*components);
         ++sRawImageCount;
 }
 
@@ -258,16 +259,6 @@ void LLImageRaw::deleteData()
         LLImageBase::deleteData();
 }
 
-BOOL LLImageRaw::copyData(U8 *data, U16 width, U16 height, S8 components)
-{
-        if (!resize(width, height, components))
-        {
-                return FALSE;
-        }
-        memcpy(getData(), data, width*height*components);
-        return TRUE;
-}
-
 BOOL LLImageRaw::resize(U16 width, U16 height, S8 components)
 {
         if ((getWidth() == width) && (getHeight() == height) && (getComponents() == components))
@@ -288,11 +279,16 @@ U8 * LLImageRaw::getSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height) const
         U8 *data = new U8[width*height*getComponents()];
 
         // Should do some simple bounds checking
+        if (!data)
+        {
+                llerrs << "Out of memory in LLImageRaw::getSubImage" << llendl;
+                return NULL;
+        }
 
         U32 i;
         for (i = y_pos; i < y_pos+height; i++)
         {
-                memcpy(data + i*width*getComponents(),
+                memcpy(data + i*width*getComponents(),          /* Flawfinder: ignore */
                                 getData() + ((y_pos + i)*getWidth() + x_pos)*getComponents(), getComponents()*width);
         }
         return data;
@@ -328,7 +324,7 @@ BOOL LLImageRaw::setSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height,
                         {
                                 from_offset = i*width*getComponents();
                         }
-                        memcpy(getData() + to_offset*getComponents(),
+                        memcpy(getData() + to_offset*getComponents(),           /* Flawfinder: ignore */
                                         data + from_offset, getComponents()*width);
                 }
         }
@@ -345,7 +341,7 @@ BOOL LLImageRaw::setSubImage(U32 x_pos, U32 y_pos, U32 width, U32 height,
                         {
                                 from_offset = (height - 1 - i)*width*getComponents();
                         }
-                        memcpy(getData() + to_offset*getComponents(),
+                        memcpy(getData() + to_offset*getComponents(),           /* Flawfinder: ignore */
                                         data + from_offset, getComponents()*width);
                 }
         }
@@ -392,14 +388,19 @@ void LLImageRaw::verticalFlip()
         LLMemType mt1((LLMemType::EMemType)mMemType);
         S32 row_bytes = getWidth() * getComponents();
         U8* line_buffer = new U8[row_bytes];
+        if (!line_buffer )
+        {
+                llerrs << "Out of memory in LLImageRaw::verticalFlip()" << llendl;
+                return;
+        }
         S32 mid_row = getHeight() / 2;
         for( S32 row = 0; row < mid_row; row++ )
         {
                 U8* row_a_data = getData() + row * row_bytes;
                 U8* row_b_data = getData() + (getHeight() - 1 - row) * row_bytes;
-                memcpy( line_buffer, row_a_data,  row_bytes );
-                memcpy( row_a_data,  row_b_data,  row_bytes );
-                memcpy( row_b_data,  line_buffer, row_bytes );
+                memcpy( line_buffer, row_a_data,  row_bytes );  /* Flawfinder: ignore */
+                memcpy( row_a_data,  row_b_data,  row_bytes );  /* Flawfinder: ignore */
+                memcpy( row_b_data,  line_buffer, row_bytes );  /* Flawfinder: ignore */
         }
         delete[] line_buffer;
 }
@@ -691,7 +692,7 @@ void LLImageRaw::copyUnscaled(LLImageRaw* src)
         llassert( src->getComponents() == dst->getComponents() );
         llassert( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) );
 
-        memcpy( dst->getData(), src->getData(), getWidth() * getHeight() * getComponents() );
+        memcpy( dst->getData(), src->getData(), getWidth() * getHeight() * getComponents() );   /* Flawfinder: ignore */
 }
 
 
@@ -775,7 +776,7 @@ void LLImageRaw::copyScaled( LLImageRaw* src )
 
         if( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) )
         {
-                memcpy( dst->getData(), src->getData(), getWidth() * getHeight() * getComponents() );
+                memcpy( dst->getData(), src->getData(), getWidth() * getHeight() * getComponents() );   /* Flawfinder: ignore */
                 return;
         }
 
@@ -841,7 +842,12 @@ void LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )
                 // copy out     existing image data
                 S32     temp_data_size = old_width * old_height * getComponents();
                 U8*     temp_buffer     = new U8[ temp_data_size ];
-                memcpy(temp_buffer,     getData(), temp_data_size);
+                if (!temp_buffer)
+                {
+                        llerrs << "Out of memory in LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )" << llendl;
+                        return;
+                }
+                memcpy(temp_buffer,     getData(), temp_data_size);     /* Flawfinder: ignore */
 
                 // allocate     new     image data,     will delete     old     data
                 U8*     new_buffer = allocateDataSize(new_width, new_height, getComponents());
@@ -850,7 +856,7 @@ void LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )
                 {
                         if (row < old_height)
                         {
-                                memcpy(new_buffer +     (new_width * row * getComponents()), temp_buffer + (old_width * row     * getComponents()),     getComponents() * llmin(old_width, new_width));
+                                memcpy(new_buffer +     (new_width * row * getComponents()), temp_buffer + (old_width * row     * getComponents()),     getComponents() * llmin(old_width, new_width)); /* Flawfinder: ignore */
                                 if (old_width < new_width)
                                 {
                                         // pad out rest of row with     black
@@ -1204,7 +1210,7 @@ bool LLImageRaw::createFromFile(const LLString &filename, bool j2c_lowest_mip_on
         llassert(image.notNull());
 
         U8 *buffer = image->allocateData(length);
-        ifs.read ((char*)buffer, length);
+        ifs.read ((char*)buffer, length);       /* Flawfinder: ignore */
         ifs.close();
         
         image->updateData();
@@ -1243,25 +1249,8 @@ bool LLImageRaw::createFromFile(const LLString &filename, bool j2c_lowest_mip_on
 //static
 S32 LLImageFormatted::sGlobalFormattedMemory = 0;
 
-//static
-LLWorkerThread* LLImageFormatted::sWorkerThread = NULL;
-
-//static
-void LLImageFormatted::initClass(bool threaded, bool run_always)
-{
-        sWorkerThread = new LLWorkerThread(threaded, run_always);
-}
-
-//static
-void LLImageFormatted::cleanupClass()
-{
-        delete sWorkerThread;
-        sWorkerThread = NULL;
-}
-
-
 LLImageFormatted::LLImageFormatted(S8 codec)
-        : LLImageBase(), LLWorkerClass(sWorkerThread, "ImageFormatted"),
+        : LLImageBase(),
           mCodec(codec),
           mDecoding(0),
           mDecoded(0),
@@ -1276,64 +1265,14 @@ LLImageFormatted::~LLImageFormatted()
         // NOTE: ~LLimageBase() call to deleteData() calls LLImageBase::deleteData()
         //        NOT LLImageFormatted::deleteData()
         deleteData();
-        releaseDecodedData();
-}
-
-//----------------------------------------------------------------------------
-
-//virtual
-void LLImageFormatted::startWork(S32 param)
-{
-        if (mDecoding) llerrs << "WTF?" << llendl;
-}
-
-bool LLImageFormatted::doWork(S32 param)
-{
-        if (!(isWorking())) llerrs << "WTF?" << llendl;
-        llassert(mDecodedImage.notNull());
-        if (param == 0)
-        {
-                // Decode primary channels
-                mDecoded = decode(mDecodedImage, .001f); // 1ms
-        }
-        else
-        {
-                // Decode aux channel
-                mDecoded = decode(mDecodedImage, .001f, param, param); // 1ms
-        }
-        if (mDecoded)
-        {
-                return true;
-        }
-        else
-        {
-                return false;
-        }
-}
-
-void LLImageFormatted::endWork(S32 param, bool aborted)
-{
-        if (mDecoding) llerrs << "WTF?" << llendl;
-        if (!mDecoded) llerrs << "WTF?" << llendl;
 }
 
 //----------------------------------------------------------------------------
 
 // static
-LLImageFormatted* LLImageFormatted::createFromExtension(const LLString& instring)
+LLImageFormatted* LLImageFormatted::createFromType(S8 codec)
 {
-        LLString exten;
-        size_t dotidx = instring.rfind('.');
-        if (dotidx != LLString::npos)
-        {
-                exten = instring.substr(dotidx+1);
-        }
-        else
-        {
-                exten = instring;
-        }
-        S8 codec = get_codec(exten);
-        LLPointer<LLImageFormatted> image;
+        LLImageFormatted* image;
         switch(codec)
         {
           case IMG_CODEC_BMP:
@@ -1354,10 +1293,28 @@ LLImageFormatted* LLImageFormatted::createFromExtension(const LLString& instring
                 image = new LLImageDXT();
                 break;
           default:
+                image = NULL;
                 break;
         }
         return image;
 }
+
+// static
+LLImageFormatted* LLImageFormatted::createFromExtension(const LLString& instring)
+{
+        LLString exten;
+        size_t dotidx = instring.rfind('.');
+        if (dotidx != LLString::npos)
+        {
+                exten = instring.substr(dotidx+1);
+        }
+        else
+        {
+                exten = instring;
+        }
+        S8 codec = get_codec(exten);
+        return createFromType(codec);
+}
 //----------------------------------------------------------------------------
 
 // virtual
@@ -1374,15 +1331,6 @@ void LLImageFormatted::dump()
 
 //----------------------------------------------------------------------------
 
-void LLImageFormatted::readHeader(U8* data, S32 size)
-{
-        if (size <= 0)
-        {
-                size = calcHeaderSize();
-        }
-        copyData(data, size); // calls updateData()
-}
-
 S32 LLImageFormatted::calcDataSize(S32 discard_level)
 {
         if (discard_level < 0)
@@ -1426,82 +1374,6 @@ BOOL LLImageFormatted::decode(LLImageRaw* raw_image,F32  decode_time, S32 first_
         return decode( raw_image, decode_time );  // Loads first 4 channels by default.
 } 
 
-// virtual
-BOOL LLImageFormatted::requestDecodedData(LLPointer<LLImageRaw>& raw, S32 discard, F32 decode_time)
-{
-        llassert(getData() && getDataSize());
-        // For most codecs, only mDiscardLevel data is available. (see LLImageDXT for exception)
-        if (discard >= 0 && discard != mDiscardLevel)
-        {
-                llerrs << "Request for invalid discard level" << llendl;
-        }
-        if (haveWork())
-        {
-                checkWork();
-        }
-        if (!mDecoded)
-        {
-                if (!haveWork())
-                {
-                        llassert(!mDecoding);
-                        mDecodedImage = new LLImageRaw(getWidth(), getHeight(), getComponents());
-                        addWork(0);
-                }
-                return FALSE;
-        }
-        else
-        {
-                llassert(mDecodedImage.notNull());
-                llassert(!mDecoding);
-                raw = mDecodedImage;
-                return TRUE;
-        }
-}
-
-BOOL LLImageFormatted::requestDecodedAuxData(LLPointer<LLImageRaw>& raw, S32 channel, 
-                                                                                         S32 discard, F32 decode_time)
-{
-        llassert(getData() && getDataSize());
-        // For most codecs, only mDiscardLevel data is available. (see LLImageDXT for exception)
-        if (discard >= 0 && discard != mDiscardLevel)
-        {
-                llerrs << "Request for invalid discard level" << llendl;
-        }
-        if (haveWork())
-        {
-                checkWork();
-        }
-        if (!mDecoded)
-        {
-                if (!haveWork())
-                {
-                        llassert(!mDecoding);
-                        mDecodedImage = new LLImageRaw(getWidth(), getHeight(), 1);
-                        addWork(channel);
-                }
-                return FALSE;
-        }
-        else
-        {
-                llassert(mDecodedImage.notNull());
-                llassert(!mDecoding);
-                raw = mDecodedImage;
-                return TRUE;
-        }
-}
-
-
-// virtual
-void LLImageFormatted::releaseDecodedData()
-{
-        if (mDecoded || mDecoding)
-        {
-                mDecodedImage = NULL; // deletes image
-                mDecoded = FALSE;
-                mDecoding = FALSE;
-        }
-}
-
 //----------------------------------------------------------------------------
 
 // virtual
@@ -1549,47 +1421,42 @@ void LLImageFormatted::sanityCheck()
 
 BOOL LLImageFormatted::copyData(U8 *data, S32 size)
 {
-        if (data && data != getData())
+        if ( (data && data != getData()) || (size != getDataSize()) )
         {
                 deleteData();
                 allocateData(size);
-                memcpy(getData(), data, size);
+                memcpy(getData(), data, size);  /* Flawfinder: ignore */
         }
-        updateData(); // virtual
-        
         return TRUE;
 }
 
-BOOL LLImageFormatted::appendData(U8 *data, S32 size)
+// LLImageFormatted becomes the owner of data
+void LLImageFormatted::setData(U8 *data, S32 size)
 {
-        LLMemType mt1((LLMemType::EMemType)mMemType);
-        S32 old_size = getDataSize();
-        U8* old_data = getData();
-        S32 new_size = old_size + size;
-        U8* new_data = new U8[new_size];
-        // resize the image
-        setDataAndSize(new_data, new_size);
-        // copy the old data and delete it
-        memcpy(new_data, old_data, old_size);
-        delete old_data;
-        // if we have new data, copy it and call updateData()
-        if (data)
+        if (data && data != getData())
         {
-                memcpy(new_data + old_size, data, size);
-                updateData(); // virtual
+                deleteData();
+                setDataAndSize(data, size); // Access private LLImageBase members
+                sGlobalFormattedMemory += getDataSize();
         }
-        return TRUE;
 }
 
-BOOL LLImageFormatted::setData(U8 *data, S32 size)
+void LLImageFormatted::appendData(U8 *data, S32 size)
 {
-        if (data && data != getData())
+        if (data)
         {
-                deleteData();
-                setDataAndSize(data, size); // Access private LLImageBase members
-                sGlobalFormattedMemory += getDataSize();
+                if (!getData())
+                {
+                        setData(data, size);
+                }
+                else 
+                {
+                        S32 cursize = getDataSize();
+                        S32 newsize = cursize + size;
+                        reallocateData(newsize);
+                        memcpy(getData() + cursize, data, size);
+                }
         }
-        return updateData(); // virtual
 }
 
 //----------------------------------------------------------------------------
@@ -1662,8 +1529,6 @@ S8 LLImageFormatted::getCodec() const
 
 //============================================================================
 
-//----------------------------------------------------------------------------
-
 static void avg4_colors4(const U8* a, const U8* b, const U8* c, const U8* d, U8* dst)
 {
         dst[0] = (U8)(((U32)(a[0]) + b[0] + c[0] + d[0])>>2);
@@ -1789,3 +1654,5 @@ F32 LLImageBase::calc_download_priority(F32 virtual_size, F32 visible_pixels, S3
 
         return w_priority;
 }
+
+//============================================================================