Image: take raw pointer to image data instead of data blob

TheMostDiligent · TheMostDiligent · commit 207280d2383c · 2024-11-06T11:33:17.000-08:00
diff --git a/AssetLoader/src/GLTFLoader.cpp b/AssetLoader/src/GLTFLoader.cpp
@@ -1715,10 +1715,8 @@ bool LoadImageData(tinygltf::Image*     gltf_image,
     }
     else
     {
-        auto pImageData = DataBlobImpl::Create(size);
-        memcpy(pImageData->GetDataPtr(), image_data, size);
         RefCntAutoPtr<Image> pImage;
-        Image::CreateFromDataBlob(pImageData, LoadInfo, &pImage);
+        Image::CreateFromMemory(image_data, size, LoadInfo, &pImage);
         if (!pImage)
         {
             if (error != nullptr)
diff --git a/TextureLoader/interface/Image.h b/TextureLoader/interface/Image.h
@@ -125,12 +125,13 @@ struct Image : public ObjectBase<IObject>
     /// \param [in] LoadInfo - Image loading information
     /// \param [out] ppImage - Memory location where pointer to the created image is written.
     ///                        The image should be released via Release().
-    static void CreateFromDataBlob(const IDataBlob*     pFileData,
-                                   const ImageLoadInfo& LoadInfo,
-                                   Image**              ppImage);
+    static void CreateFromMemory(const void*          pSrcData,
+                                 size_t               SrcDataSize,
+                                 const ImageLoadInfo& LoadInfo,
+                                 Image**              ppImage);
 
-    /// Creates a new image from memory
-    static void CreateFromMemory(const ImageDesc&         Desc,
+    /// Creates a new image using existing pixel data
+    static void CreateFromPixels(const ImageDesc&         Desc,
                                  RefCntAutoPtr<IDataBlob> pPixels,
                                  Image**                  ppImage);
 
@@ -176,7 +177,8 @@ struct Image : public ObjectBase<IObject>
     friend class MakeNewRCObj;
 
     Image(IReferenceCounters*  pRefCounters,
-          const IDataBlob*     pFileData,
+          const void*          pSrcData,
+          size_t               SrcDataSize,
           const ImageLoadInfo& LoadInfo);
 
     Image(IReferenceCounters*      pRefCounters,
diff --git a/TextureLoader/src/Image.cpp b/TextureLoader/src/Image.cpp
@@ -357,50 +357,51 @@ static bool LoadImageSTB(const void* pSrcImage,
 }
 
 Image::Image(IReferenceCounters*  pRefCounters,
-             const IDataBlob*     pFileData,
+             const void*          pSrcData,
+             size_t               SrcDataSize,
              const ImageLoadInfo& LoadInfo) :
     TBase{pRefCounters},
     m_pData{DataBlobImpl::Create(LoadInfo.pAllocator)}
 {
     if (LoadInfo.Format == IMAGE_FILE_FORMAT_TIFF)
     {
-        LoadTiffFile(pFileData->GetConstDataPtr(), pFileData->GetSize(), m_pData, m_Desc);
+        LoadTiffFile(pSrcData, SrcDataSize, m_pData, m_Desc);
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_HDR)
     {
-        if (!LoadImageSTB(pFileData->GetConstDataPtr(), pFileData->GetSize(), VT_FLOAT32, m_pData, &m_Desc))
+        if (!LoadImageSTB(pSrcData, SrcDataSize, VT_FLOAT32, m_pData, &m_Desc))
         {
             LOG_ERROR_MESSAGE("Failed to load HDR image from memory. STB only supports 32-bit rle rgbe textures");
             return;
         }
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_TGA)
     {
-        if (!LoadImageSTB(pFileData->GetConstDataPtr(), pFileData->GetSize(), VT_UINT8, m_pData, &m_Desc))
+        if (!LoadImageSTB(pSrcData, SrcDataSize, VT_UINT8, m_pData, &m_Desc))
         {
             LOG_ERROR_MESSAGE("Failed to load TGA image");
             return;
         }
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_PNG)
     {
-        if (DecodePng(pFileData->GetConstDataPtr(), pFileData->GetSize(), m_pData, &m_Desc) != DECODE_PNG_RESULT_OK)
+        if (DecodePng(pSrcData, SrcDataSize, m_pData, &m_Desc) != DECODE_PNG_RESULT_OK)
         {
             LOG_ERROR_MESSAGE("Failed to decode png image");
             return;
         }
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_JPEG)
     {
-        if (DecodeJpeg(pFileData->GetConstDataPtr(), pFileData->GetSize(), m_pData, &m_Desc) != DECODE_JPEG_RESULT_OK)
+        if (DecodeJpeg(pSrcData, SrcDataSize, m_pData, &m_Desc) != DECODE_JPEG_RESULT_OK)
         {
             LOG_ERROR_MESSAGE("Failed to decode jpeg image");
             return;
         }
     }
     else if (LoadInfo.Format == IMAGE_FILE_FORMAT_SGI)
     {
-        if (!LoadSGI(pFileData->GetConstDataPtr(), pFileData->GetSize(), m_pData, &m_Desc))
+        if (!LoadSGI(pSrcData, SrcDataSize, m_pData, &m_Desc))
         {
             LOG_ERROR_MESSAGE("Failed to load SGI image");
             return;
@@ -436,11 +437,12 @@ Image::Image(IReferenceCounters*  pRefCounters,
     }
 }
 
-void Image::CreateFromDataBlob(const IDataBlob*     pFileData,
-                               const ImageLoadInfo& LoadInfo,
-                               Image**              ppImage)
+void Image::CreateFromMemory(const void*          pSrcData,
+                             size_t               SrcDataSize,
+                             const ImageLoadInfo& LoadInfo,
+                             Image**              ppImage)
 {
-    *ppImage = MakeNewRCObj<Image>()(pFileData, LoadInfo);
+    *ppImage = MakeNewRCObj<Image>()(pSrcData, SrcDataSize, LoadInfo);
     (*ppImage)->AddRef();
 }
 
@@ -453,7 +455,7 @@ Image::Image(IReferenceCounters*      pRefCounters,
 {
 }
 
-void Image::CreateFromMemory(const ImageDesc&         Desc,
+void Image::CreateFromPixels(const ImageDesc&         Desc,
                              RefCntAutoPtr<IDataBlob> pPixels,
                              Image**                  ppImage)
 {
@@ -696,7 +698,7 @@ IMAGE_FILE_FORMAT CreateImageFromFile(const Char* FilePath,
         if (!pFileStream->IsValid())
             LOG_ERROR_AND_THROW("Failed to open image file \"", FilePath, '\"');
 
-        auto pFileData = DataBlobImpl::Create();
+        RefCntAutoPtr<DataBlobImpl> pFileData = DataBlobImpl::Create();
         pFileStream->ReadBlob(pFileData);
 
         ImgFileFormat = Image::GetFileFormat(pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), FilePath);
@@ -712,7 +714,7 @@ IMAGE_FILE_FORMAT CreateImageFromFile(const Char* FilePath,
         {
             ImageLoadInfo ImgLoadInfo;
             ImgLoadInfo.Format = ImgFileFormat;
-            Image::CreateFromDataBlob(pFileData, ImgLoadInfo, ppImage);
+            Image::CreateFromMemory(pFileData->GetConstDataPtr(), pFileData->GetSize(), ImgLoadInfo, ppImage);
         }
         else if (ppRawData != nullptr)
         {
@@ -731,6 +733,12 @@ IMAGE_FILE_FORMAT CreateImageFromMemory(const void* pImageData,
                                         size_t      DataSize,
                                         Image**     ppImage)
 {
+    if (pImageData == nullptr)
+    {
+        UNEXPECTED("pImageData must not be null");
+        return IMAGE_FILE_FORMAT_UNKNOWN;
+    }
+
     IMAGE_FILE_FORMAT ImgFileFormat = IMAGE_FILE_FORMAT_UNKNOWN;
     try
     {
@@ -743,12 +751,13 @@ IMAGE_FILE_FORMAT CreateImageFromMemory(const void* pImageData,
         if (ImgFileFormat == IMAGE_FILE_FORMAT_PNG ||
             ImgFileFormat == IMAGE_FILE_FORMAT_JPEG ||
             ImgFileFormat == IMAGE_FILE_FORMAT_TIFF ||
-            ImgFileFormat == IMAGE_FILE_FORMAT_SGI)
+            ImgFileFormat == IMAGE_FILE_FORMAT_SGI ||
+            ImgFileFormat == IMAGE_FILE_FORMAT_HDR ||
+            ImgFileFormat == IMAGE_FILE_FORMAT_TGA)
         {
             ImageLoadInfo ImgLoadInfo;
             ImgLoadInfo.Format = ImgFileFormat;
-            RefCntAutoPtr<IDataBlob> pImageDataBlob{ProxyDataBlob::Create(pImageData, DataSize)};
-            Image::CreateFromDataBlob(pImageDataBlob, ImgLoadInfo, ppImage);
+            Image::CreateFromMemory(pImageData, DataSize, ImgLoadInfo, ppImage);
         }
     }
     catch (std::runtime_error& err)
diff --git a/TextureLoader/src/TextureLoaderImpl.cpp b/TextureLoader/src/TextureLoaderImpl.cpp
@@ -152,17 +152,12 @@ TextureLoaderImpl::TextureLoaderImpl(IReferenceCounters*      pRefCounters,
         ImgFileFormat == IMAGE_FILE_FORMAT_TGA)
     {
         ImageLoadInfo ImgLoadInfo;
-        ImgLoadInfo.Format = ImgFileFormat;
-        if (!m_pDataBlob)
-        {
-            m_pDataBlob = DataBlobImpl::Create(TexLoadInfo.pAllocator, DataSize, pData);
-        }
+        ImgLoadInfo.Format           = ImgFileFormat;
         ImgLoadInfo.IsSRGB           = TexLoadInfo.IsSRGB;
         ImgLoadInfo.PermultiplyAlpha = TexLoadInfo.PermultiplyAlpha;
         ImgLoadInfo.pAllocator       = TexLoadInfo.pAllocator;
         RefCntAutoPtr<Image> pImage;
-        Image::CreateFromDataBlob(m_pDataBlob, ImgLoadInfo, &pImage);
-        m_pDataBlob.Release();
+        Image::CreateFromMemory(pData, DataSize, ImgLoadInfo, &pImage);
         LoadFromImage(std::move(pImage), TexLoadInfo);
     }
     else

Original file line number	Diff line number	Diff line change
`@@ -1715,10 +1715,8 @@ bool LoadImageData(tinygltf::Image* gltf_image,`
`1715`	`1715`	`}`
`1716`	`1716`	`else`
`1717`	`1717`	`{`
`1718`		`- auto pImageData = DataBlobImpl::Create(size);`
`1719`		`- memcpy(pImageData->GetDataPtr(), image_data, size);`
`1720`	`1718`	`RefCntAutoPtr<Image> pImage;`
`1721`		`- Image::CreateFromDataBlob(pImageData, LoadInfo, &pImage);`
	`1719`	`+ Image::CreateFromMemory(image_data, size, LoadInfo, &pImage);`
`1722`	`1720`	`if (!pImage)`
`1723`	`1721`	`{`
`1724`	`1722`	`if (error != nullptr)`
Original file line number	Diff line number	Diff line change
`@@ -357,50 +357,51 @@ static bool LoadImageSTB(const void* pSrcImage,`
`357`	`357`	`}`
`358`	`358`
`359`	`359`	`Image::Image(IReferenceCounters* pRefCounters,`
`360`		`- const IDataBlob* pFileData,`
	`360`	`+ const void* pSrcData,`
	`361`	`+ size_t SrcDataSize,`
`361`	`362`	`const ImageLoadInfo& LoadInfo) :`
`362`	`363`	`TBase{pRefCounters},`
`363`	`364`	`m_pData{DataBlobImpl::Create(LoadInfo.pAllocator)}`
`364`	`365`	`{`
`365`	`366`	`if (LoadInfo.Format == IMAGE_FILE_FORMAT_TIFF)`
`366`	`367`	`{`
`367`		`- LoadTiffFile(pFileData->GetConstDataPtr(), pFileData->GetSize(), m_pData, m_Desc);`
	`368`	`+ LoadTiffFile(pSrcData, SrcDataSize, m_pData, m_Desc);`
`368`	`369`	`}`
`369`	`370`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_HDR)`
`370`	`371`	`{`
`371`		`- if (!LoadImageSTB(pFileData->GetConstDataPtr(), pFileData->GetSize(), VT_FLOAT32, m_pData, &m_Desc))`
	`372`	`+ if (!LoadImageSTB(pSrcData, SrcDataSize, VT_FLOAT32, m_pData, &m_Desc))`
`372`	`373`	`{`
`373`	`374`	`LOG_ERROR_MESSAGE("Failed to load HDR image from memory. STB only supports 32-bit rle rgbe textures");`
`374`	`375`	`return;`
`375`	`376`	`}`
`376`	`377`	`}`
`377`	`378`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_TGA)`
`378`	`379`	`{`
`379`		`- if (!LoadImageSTB(pFileData->GetConstDataPtr(), pFileData->GetSize(), VT_UINT8, m_pData, &m_Desc))`
	`380`	`+ if (!LoadImageSTB(pSrcData, SrcDataSize, VT_UINT8, m_pData, &m_Desc))`
`380`	`381`	`{`
`381`	`382`	`LOG_ERROR_MESSAGE("Failed to load TGA image");`
`382`	`383`	`return;`
`383`	`384`	`}`
`384`	`385`	`}`
`385`	`386`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_PNG)`
`386`	`387`	`{`
`387`		`- if (DecodePng(pFileData->GetConstDataPtr(), pFileData->GetSize(), m_pData, &m_Desc) != DECODE_PNG_RESULT_OK)`
	`388`	`+ if (DecodePng(pSrcData, SrcDataSize, m_pData, &m_Desc) != DECODE_PNG_RESULT_OK)`
`388`	`389`	`{`
`389`	`390`	`LOG_ERROR_MESSAGE("Failed to decode png image");`
`390`	`391`	`return;`
`391`	`392`	`}`
`392`	`393`	`}`
`393`	`394`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_JPEG)`
`394`	`395`	`{`
`395`		`- if (DecodeJpeg(pFileData->GetConstDataPtr(), pFileData->GetSize(), m_pData, &m_Desc) != DECODE_JPEG_RESULT_OK)`
	`396`	`+ if (DecodeJpeg(pSrcData, SrcDataSize, m_pData, &m_Desc) != DECODE_JPEG_RESULT_OK)`
`396`	`397`	`{`
`397`	`398`	`LOG_ERROR_MESSAGE("Failed to decode jpeg image");`
`398`	`399`	`return;`
`399`	`400`	`}`
`400`	`401`	`}`
`401`	`402`	`else if (LoadInfo.Format == IMAGE_FILE_FORMAT_SGI)`
`402`	`403`	`{`
`403`		`- if (!LoadSGI(pFileData->GetConstDataPtr(), pFileData->GetSize(), m_pData, &m_Desc))`
	`404`	`+ if (!LoadSGI(pSrcData, SrcDataSize, m_pData, &m_Desc))`
`404`	`405`	`{`
`405`	`406`	`LOG_ERROR_MESSAGE("Failed to load SGI image");`
`406`	`407`	`return;`
`@@ -436,11 +437,12 @@ Image::Image(IReferenceCounters* pRefCounters,`
`436`	`437`	`}`
`437`	`438`	`}`
`438`	`439`
`439`		`-void Image::CreateFromDataBlob(const IDataBlob* pFileData,`
`440`		`- const ImageLoadInfo& LoadInfo,`
`441`		`- Image** ppImage)`
	`440`	`+void Image::CreateFromMemory(const void* pSrcData,`
	`441`	`+ size_t SrcDataSize,`
	`442`	`+ const ImageLoadInfo& LoadInfo,`
	`443`	`+ Image** ppImage)`
`442`	`444`	`{`
`443`		`- *ppImage = MakeNewRCObj<Image>()(pFileData, LoadInfo);`
	`445`	`+ *ppImage = MakeNewRCObj<Image>()(pSrcData, SrcDataSize, LoadInfo);`
`444`	`446`	`(*ppImage)->AddRef();`
`445`	`447`	`}`
`446`	`448`
`@@ -453,7 +455,7 @@ Image::Image(IReferenceCounters* pRefCounters,`
`453`	`455`	`{`
`454`	`456`	`}`
`455`	`457`
`456`		`-void Image::CreateFromMemory(const ImageDesc& Desc,`
	`458`	`+void Image::CreateFromPixels(const ImageDesc& Desc,`
`457`	`459`	`RefCntAutoPtr<IDataBlob> pPixels,`
`458`	`460`	`Image** ppImage)`
`459`	`461`	`{`
`@@ -696,7 +698,7 @@ IMAGE_FILE_FORMAT CreateImageFromFile(const Char* FilePath,`
`696`	`698`	`if (!pFileStream->IsValid())`
`697`	`699`	`LOG_ERROR_AND_THROW("Failed to open image file \"", FilePath, '\"');`
`698`	`700`
`699`		`- auto pFileData = DataBlobImpl::Create();`
	`701`	`+ RefCntAutoPtr<DataBlobImpl> pFileData = DataBlobImpl::Create();`
`700`	`702`	`pFileStream->ReadBlob(pFileData);`
`701`	`703`
`702`	`704`	`ImgFileFormat = Image::GetFileFormat(pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), FilePath);`
`@@ -712,7 +714,7 @@ IMAGE_FILE_FORMAT CreateImageFromFile(const Char* FilePath,`
`712`	`714`	`{`
`713`	`715`	`ImageLoadInfo ImgLoadInfo;`
`714`	`716`	`ImgLoadInfo.Format = ImgFileFormat;`
`715`		`- Image::CreateFromDataBlob(pFileData, ImgLoadInfo, ppImage);`
	`717`	`+ Image::CreateFromMemory(pFileData->GetConstDataPtr(), pFileData->GetSize(), ImgLoadInfo, ppImage);`
`716`	`718`	`}`
`717`	`719`	`else if (ppRawData != nullptr)`
`718`	`720`	`{`
`@@ -731,6 +733,12 @@ IMAGE_FILE_FORMAT CreateImageFromMemory(const void* pImageData,`
`731`	`733`	`size_t DataSize,`
`732`	`734`	`Image** ppImage)`
`733`	`735`	`{`
	`736`	`+ if (pImageData == nullptr)`
	`737`	`+ {`
	`738`	`+ UNEXPECTED("pImageData must not be null");`
	`739`	`+ return IMAGE_FILE_FORMAT_UNKNOWN;`
	`740`	`+ }`
	`741`	`+`
`734`	`742`	`IMAGE_FILE_FORMAT ImgFileFormat = IMAGE_FILE_FORMAT_UNKNOWN;`
`735`	`743`	`try`
`736`	`744`	`{`
`@@ -743,12 +751,13 @@ IMAGE_FILE_FORMAT CreateImageFromMemory(const void* pImageData,`
`743`	`751`	`if (ImgFileFormat == IMAGE_FILE_FORMAT_PNG \|\|`
`744`	`752`	`ImgFileFormat == IMAGE_FILE_FORMAT_JPEG \|\|`
`745`	`753`	`ImgFileFormat == IMAGE_FILE_FORMAT_TIFF \|\|`
`746`		`- ImgFileFormat == IMAGE_FILE_FORMAT_SGI)`
	`754`	`+ ImgFileFormat == IMAGE_FILE_FORMAT_SGI \|\|`
	`755`	`+ ImgFileFormat == IMAGE_FILE_FORMAT_HDR \|\|`
	`756`	`+ ImgFileFormat == IMAGE_FILE_FORMAT_TGA)`
`747`	`757`	`{`
`748`	`758`	`ImageLoadInfo ImgLoadInfo;`
`749`	`759`	`ImgLoadInfo.Format = ImgFileFormat;`
`750`		`- RefCntAutoPtr<IDataBlob> pImageDataBlob{ProxyDataBlob::Create(pImageData, DataSize)};`
`751`		`- Image::CreateFromDataBlob(pImageDataBlob, ImgLoadInfo, ppImage);`
	`760`	`+ Image::CreateFromMemory(pImageData, DataSize, ImgLoadInfo, ppImage);`
`752`	`761`	`}`
`753`	`762`	`}`
`754`	`763`	`catch (std::runtime_error& err)`