Texture Loader: memory usage improvements

TheMostDiligent · TheMostDiligent · commit ef6fbe65b64d · 2024-11-05T13:12:15.000-08:00
diff --git a/TextureLoader/include/TextureLoaderImpl.hpp b/TextureLoader/include/TextureLoaderImpl.hpp
@@ -39,15 +39,15 @@ class TextureLoaderImpl final : public ObjectBase<ITextureLoader>
 public:
     using TBase = ObjectBase<ITextureLoader>;
 
-    TextureLoaderImpl(IReferenceCounters*        pRefCounters,
-                      const TextureLoadInfo&     TexLoadInfo,
-                      const Uint8*               pData,
-                      size_t                     DataSize,
-                      RefCntAutoPtr<IDataBlob>&& pDataBlob);
+    TextureLoaderImpl(IReferenceCounters*      pRefCounters,
+                      const TextureLoadInfo&   TexLoadInfo,
+                      const Uint8*             pData,
+                      size_t                   DataSize,
+                      RefCntAutoPtr<IDataBlob> pDataBlob);
 
     TextureLoaderImpl(IReferenceCounters*    pRefCounters,
                       const TextureLoadInfo& TexLoadInfo,
-                      Image*                 pImage);
+                      RefCntAutoPtr<Image>   pImage);
 
     IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_TextureLoader, TBase)
 
@@ -73,7 +73,7 @@ class TextureLoaderImpl final : public ObjectBase<ITextureLoader>
     }
 
 private:
-    void LoadFromImage(Image* pImage, const TextureLoadInfo& TexLoadInfo);
+    void LoadFromImage(RefCntAutoPtr<Image> pImage, const TextureLoadInfo& TexLoadInfo);
     void LoadFromKTX(const TextureLoadInfo& TexLoadInfo, const Uint8* pData, size_t DataSize);
     void LoadFromDDS(const TextureLoadInfo& TexLoadInfo, const Uint8* pData, size_t DataSize);
     void CompressSubresources(Uint32 NumComponents, Uint32 NumSrcComponents, const TextureLoadInfo& TexLoadInfo);
diff --git a/TextureLoader/src/Image.cpp b/TextureLoader/src/Image.cpp
@@ -339,31 +339,31 @@ Image::Image(IReferenceCounters*  pRefCounters,
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_HDR)
     {
-        bool Res = LoadHDRFile(pFileData, m_pData.RawPtr(), &m_Desc);
+        bool Res = LoadHDRFile(pFileData, m_pData, &m_Desc);
         if (!Res)
             LOG_ERROR_MESSAGE("Failed to load HDR image");
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_TGA)
     {
-        bool Res = LoadTGAFile(pFileData, m_pData.RawPtr(), &m_Desc);
+        bool Res = LoadTGAFile(pFileData, m_pData, &m_Desc);
         if (!Res)
             LOG_ERROR_MESSAGE("Failed to load TGA image");
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_PNG)
     {
-        auto Res = DecodePng(pFileData, m_pData.RawPtr(), &m_Desc);
+        auto Res = DecodePng(pFileData, m_pData, &m_Desc);
         if (Res != DECODE_PNG_RESULT_OK)
             LOG_ERROR_MESSAGE("Failed to decode png image");
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_JPEG)
     {
-        auto Res = DecodeJpeg(pFileData, m_pData.RawPtr(), &m_Desc);
+        auto Res = DecodeJpeg(pFileData, m_pData, &m_Desc);
         if (Res != DECODE_JPEG_RESULT_OK)
             LOG_ERROR_MESSAGE("Failed to decode jpeg image");
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_SGI)
     {
-        auto Res = LoadSGI(pFileData, m_pData.RawPtr(), &m_Desc);
+        auto Res = LoadSGI(pFileData, m_pData, &m_Desc);
         if (!Res)
             LOG_ERROR_MESSAGE("Failed to load SGI image");
     }
@@ -481,7 +481,7 @@ void Image::Encode(const EncodeInfo& Info, IDataBlob** ppEncodedData)
     {
         auto RGBData = ConvertImageData(Info.Width, Info.Height, reinterpret_cast<const Uint8*>(Info.pData), Info.Stride, Info.TexFormat, TEX_FORMAT_RGBA8_UNORM, false, Info.FlipY);
 
-        auto Res = EncodeJpeg(RGBData.data(), Info.Width, Info.Height, Info.JpegQuality, pEncodedData.RawPtr());
+        auto Res = EncodeJpeg(RGBData.data(), Info.Width, Info.Height, Info.JpegQuality, pEncodedData);
         if (Res != ENCODE_JPEG_RESULT_OK)
             LOG_ERROR_MESSAGE("Failed to encode jpeg file");
     }
@@ -497,7 +497,7 @@ void Image::Encode(const EncodeInfo& Info, IDataBlob** ppEncodedData)
             Stride        = Info.Width * (Info.KeepAlpha ? 4 : 3);
         }
 
-        auto Res = EncodePng(pData, Info.Width, Info.Height, Stride, Info.KeepAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB, pEncodedData.RawPtr());
+        auto Res = EncodePng(pData, Info.Width, Info.Height, Stride, Info.KeepAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB, pEncodedData);
         if (Res != ENCODE_PNG_RESULT_OK)
             LOG_ERROR_MESSAGE("Failed to encode png file");
     }
diff --git a/TextureLoader/src/TextureLoaderImpl.cpp b/TextureLoader/src/TextureLoaderImpl.cpp
@@ -124,11 +124,11 @@ static TextureDesc TexDescFromTexLoadInfo(const TextureLoadInfo& TexLoadInfo, co
     return TexDesc;
 }
 
-TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters*        pRefCounters,
-                                     const TextureLoadInfo&     TexLoadInfo,
-                                     const Uint8*               pData,
-                                     size_t                     DataSize,
-                                     RefCntAutoPtr<IDataBlob>&& pDataBlob) :
+TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters*      pRefCounters,
+                                     const TextureLoadInfo&   TexLoadInfo,
+                                     const Uint8*             pData,
+                                     size_t                   DataSize,
+                                     RefCntAutoPtr<IDataBlob> pDataBlob) :
     TBase{pRefCounters},
     m_pDataBlob{std::move(pDataBlob)},
     m_Name{TexLoadInfo.Name != nullptr ? TexLoadInfo.Name : ""},
@@ -158,8 +158,8 @@ TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters*        pRefCounters,
         ImgLoadInfo.pAllocator       = TexLoadInfo.pAllocator;
         RefCntAutoPtr<Image> pImage;
         Image::CreateFromDataBlob(m_pDataBlob, ImgLoadInfo, &pImage);
-        LoadFromImage(pImage, TexLoadInfo);
         m_pDataBlob.Release();
+        LoadFromImage(std::move(pImage), TexLoadInfo);
     }
     else
     {
@@ -181,12 +181,12 @@ TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters*        pRefCounters,
 
 TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters*    pRefCounters,
                                      const TextureLoadInfo& TexLoadInfo,
-                                     Image*                 pImage) :
+                                     RefCntAutoPtr<Image>   pImage) :
     TBase{pRefCounters},
     m_Name{TexLoadInfo.Name != nullptr ? TexLoadInfo.Name : ""},
     m_TexDesc{TexDescFromTexLoadInfo(TexLoadInfo, m_Name)}
 {
-    LoadFromImage(pImage, TexLoadInfo);
+    LoadFromImage(std::move(pImage), TexLoadInfo);
 }
 
 void TextureLoaderImpl::CreateTexture(IRenderDevice* pDevice,
@@ -196,7 +196,7 @@ void TextureLoaderImpl::CreateTexture(IRenderDevice* pDevice,
     pDevice->CreateTexture(m_TexDesc, &InitData, ppTexture);
 }
 
-void TextureLoaderImpl::LoadFromImage(Image* pImage, const TextureLoadInfo& TexLoadInfo)
+void TextureLoaderImpl::LoadFromImage(RefCntAutoPtr<Image> pImage, const TextureLoadInfo& TexLoadInfo)
 {
     VERIFY_EXPR(pImage != nullptr);
 
@@ -301,12 +301,14 @@ void TextureLoaderImpl::LoadFromImage(Image* pImage, const TextureLoadInfo& TexL
         }
 
         CopyPixels(CopyAttribs);
+        // Release original image
+        pImage.Release();
     }
     else
     {
         // Keep strong reference to the image to prevent it from being destroyed
         // since we are going to use its data directly.
-        m_pImage                 = pImage;
+        m_pImage                 = std::move(pImage);
         m_SubResources[0].pData  = m_pImage->GetData()->GetConstDataPtr();
         m_SubResources[0].Stride = ImgDesc.RowStride;
     }
@@ -459,6 +461,7 @@ void TextureLoaderImpl::CompressSubresources(Uint32 NumComponents, Uint32 NumSrc
 
             SubResData.pData  = CompressedMip->GetDataPtr();
             SubResData.Stride = CompressedStride;
+            m_Mips[SubResIndex].Release();
         }
     }
 
@@ -481,8 +484,8 @@ void CreateTextureLoaderFromFile(const char*            FilePath,
         RefCntAutoPtr<DataBlobImpl> pFileData = DataBlobImpl::Create(TexLoadInfo.pAllocator);
         File->Read(pFileData);
 
-        RefCntAutoPtr<ITextureLoader> pTexLoader{
-            MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), std::move(pFileData)) //
+        RefCntAutoPtr<TextureLoaderImpl> pTexLoader{
+            MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), std::move(pFileData)),
         };
         if (pTexLoader)
             pTexLoader->QueryInterface(IID_TextureLoader, reinterpret_cast<IObject**>(ppLoader));
@@ -541,7 +544,7 @@ void CreateTextureLoaderFromImage(Image*                 pSrcImage,
     VERIFY_EXPR(pSrcImage != nullptr);
     try
     {
-        RefCntAutoPtr<ITextureLoader> pTexLoader{MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, pSrcImage)};
+        RefCntAutoPtr<ITextureLoader> pTexLoader{MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, RefCntAutoPtr<Image>{pSrcImage})};
         if (pTexLoader)
             pTexLoader->QueryInterface(IID_TextureLoader, reinterpret_cast<IObject**>(ppLoader));
     }

Original file line number	Diff line number	Diff line change
`@@ -339,31 +339,31 @@ Image::Image(IReferenceCounters* pRefCounters,`
`339`	`339`	`}`
`340`	`340`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_HDR)`
`341`	`341`	`{`
`342`		`- bool Res = LoadHDRFile(pFileData, m_pData.RawPtr(), &m_Desc);`
	`342`	`+ bool Res = LoadHDRFile(pFileData, m_pData, &m_Desc);`
`343`	`343`	`if (!Res)`
`344`	`344`	`LOG_ERROR_MESSAGE("Failed to load HDR image");`
`345`	`345`	`}`
`346`	`346`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_TGA)`
`347`	`347`	`{`
`348`		`- bool Res = LoadTGAFile(pFileData, m_pData.RawPtr(), &m_Desc);`
	`348`	`+ bool Res = LoadTGAFile(pFileData, m_pData, &m_Desc);`
`349`	`349`	`if (!Res)`
`350`	`350`	`LOG_ERROR_MESSAGE("Failed to load TGA image");`
`351`	`351`	`}`
`352`	`352`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_PNG)`
`353`	`353`	`{`
`354`		`- auto Res = DecodePng(pFileData, m_pData.RawPtr(), &m_Desc);`
	`354`	`+ auto Res = DecodePng(pFileData, m_pData, &m_Desc);`
`355`	`355`	`if (Res != DECODE_PNG_RESULT_OK)`
`356`	`356`	`LOG_ERROR_MESSAGE("Failed to decode png image");`
`357`	`357`	`}`
`358`	`358`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_JPEG)`
`359`	`359`	`{`
`360`		`- auto Res = DecodeJpeg(pFileData, m_pData.RawPtr(), &m_Desc);`
	`360`	`+ auto Res = DecodeJpeg(pFileData, m_pData, &m_Desc);`
`361`	`361`	`if (Res != DECODE_JPEG_RESULT_OK)`
`362`	`362`	`LOG_ERROR_MESSAGE("Failed to decode jpeg image");`
`363`	`363`	`}`
`364`	`364`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_SGI)`
`365`	`365`	`{`
`366`		`- auto Res = LoadSGI(pFileData, m_pData.RawPtr(), &m_Desc);`
	`366`	`+ auto Res = LoadSGI(pFileData, m_pData, &m_Desc);`
`367`	`367`	`if (!Res)`
`368`	`368`	`LOG_ERROR_MESSAGE("Failed to load SGI image");`
`369`	`369`	`}`
`@@ -481,7 +481,7 @@ void Image::Encode(const EncodeInfo& Info, IDataBlob** ppEncodedData)`
`481`	`481`	`{`
`482`	`482`	`auto RGBData = ConvertImageData(Info.Width, Info.Height, reinterpret_cast<const Uint8*>(Info.pData), Info.Stride, Info.TexFormat, TEX_FORMAT_RGBA8_UNORM, false, Info.FlipY);`
`483`	`483`
`484`		`- auto Res = EncodeJpeg(RGBData.data(), Info.Width, Info.Height, Info.JpegQuality, pEncodedData.RawPtr());`
	`484`	`+ auto Res = EncodeJpeg(RGBData.data(), Info.Width, Info.Height, Info.JpegQuality, pEncodedData);`
`485`	`485`	`if (Res != ENCODE_JPEG_RESULT_OK)`
`486`	`486`	`LOG_ERROR_MESSAGE("Failed to encode jpeg file");`
`487`	`487`	`}`
`@@ -497,7 +497,7 @@ void Image::Encode(const EncodeInfo& Info, IDataBlob** ppEncodedData)`
`497`	`497`	`Stride = Info.Width * (Info.KeepAlpha ? 4 : 3);`
`498`	`498`	`}`
`499`	`499`
`500`		`- auto Res = EncodePng(pData, Info.Width, Info.Height, Stride, Info.KeepAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB, pEncodedData.RawPtr());`
	`500`	`+ auto Res = EncodePng(pData, Info.Width, Info.Height, Stride, Info.KeepAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB, pEncodedData);`
`501`	`501`	`if (Res != ENCODE_PNG_RESULT_OK)`
`502`	`502`	`LOG_ERROR_MESSAGE("Failed to encode png file");`
`503`	`503`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,11 +124,11 @@ static TextureDesc TexDescFromTexLoadInfo(const TextureLoadInfo& TexLoadInfo, co`
`124`	`124`	`return TexDesc;`
`125`	`125`	`}`
`126`	`126`
`127`		`-TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters* pRefCounters,`
`128`		`- const TextureLoadInfo& TexLoadInfo,`
`129`		`- const Uint8* pData,`
`130`		`- size_t DataSize,`
`131`		`- RefCntAutoPtr<IDataBlob>&& pDataBlob) :`
	`127`	`+TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters* pRefCounters,`
	`128`	`+ const TextureLoadInfo& TexLoadInfo,`
	`129`	`+ const Uint8* pData,`
	`130`	`+ size_t DataSize,`
	`131`	`+ RefCntAutoPtr<IDataBlob> pDataBlob) :`
`132`	`132`	`TBase{pRefCounters},`
`133`	`133`	`m_pDataBlob{std::move(pDataBlob)},`
`134`	`134`	`m_Name{TexLoadInfo.Name != nullptr ? TexLoadInfo.Name : ""},`
`@@ -158,8 +158,8 @@ TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters* pRefCounters,`
`158`	`158`	`ImgLoadInfo.pAllocator = TexLoadInfo.pAllocator;`
`159`	`159`	`RefCntAutoPtr<Image> pImage;`
`160`	`160`	`Image::CreateFromDataBlob(m_pDataBlob, ImgLoadInfo, &pImage);`
`161`		`- LoadFromImage(pImage, TexLoadInfo);`
`162`	`161`	`m_pDataBlob.Release();`
	`162`	`+ LoadFromImage(std::move(pImage), TexLoadInfo);`
`163`	`163`	`}`
`164`	`164`	`else`
`165`	`165`	`{`
`@@ -181,12 +181,12 @@ TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters* pRefCounters,`
`181`	`181`
`182`	`182`	`TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters* pRefCounters,`
`183`	`183`	`const TextureLoadInfo& TexLoadInfo,`
`184`		`- Image* pImage) :`
	`184`	`+ RefCntAutoPtr<Image> pImage) :`
`185`	`185`	`TBase{pRefCounters},`
`186`	`186`	`m_Name{TexLoadInfo.Name != nullptr ? TexLoadInfo.Name : ""},`
`187`	`187`	`m_TexDesc{TexDescFromTexLoadInfo(TexLoadInfo, m_Name)}`
`188`	`188`	`{`
`189`		`- LoadFromImage(pImage, TexLoadInfo);`
	`189`	`+ LoadFromImage(std::move(pImage), TexLoadInfo);`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`void TextureLoaderImpl::CreateTexture(IRenderDevice* pDevice,`
`@@ -196,7 +196,7 @@ void TextureLoaderImpl::CreateTexture(IRenderDevice* pDevice,`
`196`	`196`	`pDevice->CreateTexture(m_TexDesc, &InitData, ppTexture);`
`197`	`197`	`}`
`198`	`198`
`199`		`-void TextureLoaderImpl::LoadFromImage(Image* pImage, const TextureLoadInfo& TexLoadInfo)`
	`199`	`+void TextureLoaderImpl::LoadFromImage(RefCntAutoPtr<Image> pImage, const TextureLoadInfo& TexLoadInfo)`
`200`	`200`	`{`
`201`	`201`	`VERIFY_EXPR(pImage != nullptr);`
`202`	`202`
`@@ -301,12 +301,14 @@ void TextureLoaderImpl::LoadFromImage(Image* pImage, const TextureLoadInfo& TexL`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`CopyPixels(CopyAttribs);`
	`304`	`+ // Release original image`
	`305`	`+ pImage.Release();`
`304`	`306`	`}`
`305`	`307`	`else`
`306`	`308`	`{`
`307`	`309`	`// Keep strong reference to the image to prevent it from being destroyed`
`308`	`310`	`// since we are going to use its data directly.`
`309`		`- m_pImage = pImage;`
	`311`	`+ m_pImage = std::move(pImage);`
`310`	`312`	`m_SubResources[0].pData = m_pImage->GetData()->GetConstDataPtr();`
`311`	`313`	`m_SubResources[0].Stride = ImgDesc.RowStride;`
`312`	`314`	`}`
`@@ -459,6 +461,7 @@ void TextureLoaderImpl::CompressSubresources(Uint32 NumComponents, Uint32 NumSrc`
`459`	`461`
`460`	`462`	`SubResData.pData = CompressedMip->GetDataPtr();`
`461`	`463`	`SubResData.Stride = CompressedStride;`
	`464`	`+ m_Mips[SubResIndex].Release();`
`462`	`465`	`}`
`463`	`466`	`}`
`464`	`467`
`@@ -481,8 +484,8 @@ void CreateTextureLoaderFromFile(const char* FilePath,`
`481`	`484`	`RefCntAutoPtr<DataBlobImpl> pFileData = DataBlobImpl::Create(TexLoadInfo.pAllocator);`
`482`	`485`	`File->Read(pFileData);`
`483`	`486`
`484`		`- RefCntAutoPtr<ITextureLoader> pTexLoader{`
`485`		`- MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), std::move(pFileData)) //`
	`487`	`+ RefCntAutoPtr<TextureLoaderImpl> pTexLoader{`
	`488`	`+ MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), std::move(pFileData)),`
`486`	`489`	`};`
`487`	`490`	`if (pTexLoader)`
`488`	`491`	`pTexLoader->QueryInterface(IID_TextureLoader, reinterpret_cast<IObject**>(ppLoader));`
`@@ -541,7 +544,7 @@ void CreateTextureLoaderFromImage(Image* pSrcImage,`
`541`	`544`	`VERIFY_EXPR(pSrcImage != nullptr);`
`542`	`545`	`try`
`543`	`546`	`{`
`544`		`- RefCntAutoPtr<ITextureLoader> pTexLoader{MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, pSrcImage)};`
	`547`	`+ RefCntAutoPtr<ITextureLoader> pTexLoader{MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, RefCntAutoPtr<Image>{pSrcImage})};`
`545`	`548`	`if (pTexLoader)`
`546`	`549`	`pTexLoader->QueryInterface(IID_TextureLoader, reinterpret_cast<IObject**>(ppLoader));`
`547`	`550`	`}`