From: =?utf-8?q?Timo_R=C3=B6hling?= <timo@gaussglocke.de>
Date: Tue, 17 Nov 2020 17:06:24 +0100
Subject: Explicitly export required symbols

Forwarded: not-needed
---
 tinyexr.h | 64 ++++++++++++++++++++++++++++++++++-----------------------------
 1 file changed, 35 insertions(+), 29 deletions(-)

diff --git a/tinyexr.h b/tinyexr.h
index 00f338d..7979252 100644
--- a/tinyexr.h
+++ b/tinyexr.h
@@ -643,6 +643,12 @@ extern int LoadEXRFromMemory(float **out_rgba, int *width, int *height,
 #ifndef TINYEXR_IMPLEMENTATION_DEFINED
 #define TINYEXR_IMPLEMENTATION_DEFINED
 
+#ifdef tinyexr_EXPORTS
+#define TINYEXR_PUBLIC __attribute__((visibility ("default")))
+#else
+#define TINYEXR_PUBLIC
+#endif
+
 #ifdef _WIN32
 
 #ifndef WIN32_LEAN_AND_MEAN
@@ -6214,7 +6220,7 @@ static void ChannelsInLayer(const EXRHeader &exr_header,
 
 }  // namespace tinyexr
 
-int EXRLayers(const char *filename, const char **layer_names[], int *num_layers,
+TINYEXR_PUBLIC int EXRLayers(const char *filename, const char **layer_names[], int *num_layers,
               const char **err) {
   EXRVersion exr_version;
   EXRHeader exr_header;
@@ -6259,13 +6265,13 @@ int EXRLayers(const char *filename, const char **layer_names[], int *num_layers,
   return TINYEXR_SUCCESS;
 }
 
-int LoadEXR(float **out_rgba, int *width, int *height, const char *filename,
+TINYEXR_PUBLIC int LoadEXR(float **out_rgba, int *width, int *height, const char *filename,
             const char **err) {
   return LoadEXRWithLayer(out_rgba, width, height, filename,
                           /* layername */ NULL, err);
 }
 
-int LoadEXRWithLayer(float **out_rgba, int *width, int *height,
+TINYEXR_PUBLIC int LoadEXRWithLayer(float **out_rgba, int *width, int *height,
                      const char *filename, const char *layername,
                      const char **err) {
   if (out_rgba == NULL) {
@@ -6513,7 +6519,7 @@ int LoadEXRWithLayer(float **out_rgba, int *width, int *height,
   return TINYEXR_SUCCESS;
 }
 
-int IsEXR(const char *filename) {
+TINYEXR_PUBLIC int IsEXR(const char *filename) {
   EXRVersion exr_version;
 
   int ret = ParseEXRVersionFromFile(&exr_version, filename);
@@ -6524,7 +6530,7 @@ int IsEXR(const char *filename) {
   return TINYEXR_SUCCESS;
 }
 
-int IsEXRFromMemory(const unsigned char *memory, size_t size) {
+TINYEXR_PUBLIC int IsEXRFromMemory(const unsigned char *memory, size_t size) {
   EXRVersion exr_version;
 
   int ret = ParseEXRVersionFromMemory(&exr_version, memory, size);
@@ -6535,7 +6541,7 @@ int IsEXRFromMemory(const unsigned char *memory, size_t size) {
   return TINYEXR_SUCCESS;
 }
 
-int ParseEXRHeaderFromMemory(EXRHeader *exr_header, const EXRVersion *version,
+TINYEXR_PUBLIC int ParseEXRHeaderFromMemory(EXRHeader *exr_header, const EXRVersion *version,
                              const unsigned char *memory, size_t size,
                              const char **err) {
   if (memory == NULL || exr_header == NULL) {
@@ -6595,7 +6601,7 @@ int ParseEXRHeaderFromMemory(EXRHeader *exr_header, const EXRVersion *version,
   return ret;
 }
 
-int LoadEXRFromMemory(float **out_rgba, int *width, int *height,
+TINYEXR_PUBLIC int LoadEXRFromMemory(float **out_rgba, int *width, int *height,
                       const unsigned char *memory, size_t size,
                       const char **err) {
   if (out_rgba == NULL || memory == NULL) {
@@ -6996,7 +7002,7 @@ struct MemoryMappedFile {
   bool valid() const { return data; }
 };
 
-int LoadEXRImageFromFile(EXRImage *exr_image, const EXRHeader *exr_header,
+TINYEXR_PUBLIC int LoadEXRImageFromFile(EXRImage *exr_image, const EXRHeader *exr_header,
                          const char *filename, const char **err) {
   if (exr_image == NULL) {
     tinyexr::SetErrorMessage("Invalid argument for LoadEXRImageFromFile", err);
@@ -7019,7 +7025,7 @@ int LoadEXRImageFromFile(EXRImage *exr_image, const EXRHeader *exr_header,
                                 err);
 }
 
-int LoadEXRImageFromMemory(EXRImage *exr_image, const EXRHeader *exr_header,
+TINYEXR_PUBLIC int LoadEXRImageFromMemory(EXRImage *exr_image, const EXRHeader *exr_header,
                            const unsigned char *memory, const size_t size,
                            const char **err) {
   if (exr_image == NULL || memory == NULL ||
@@ -8069,13 +8075,13 @@ static size_t SaveEXRNPartImageToMemory(const EXRImage* exr_images,
 
 } // tinyexr
 
-size_t SaveEXRImageToMemory(const EXRImage* exr_image,
+TINYEXR_PUBLIC size_t SaveEXRImageToMemory(const EXRImage* exr_image,
                              const EXRHeader* exr_header,
                              unsigned char** memory_out, const char** err) {
   return tinyexr::SaveEXRNPartImageToMemory(exr_image, &exr_header, 1, memory_out, err);
 }
 
-int SaveEXRImageToFile(const EXRImage *exr_image, const EXRHeader *exr_header,
+TINYEXR_PUBLIC int SaveEXRImageToFile(const EXRImage *exr_image, const EXRHeader *exr_header,
                        const char *filename, const char **err) {
   if (exr_image == NULL || filename == NULL ||
       exr_header->compression_type < 0) {
@@ -8145,7 +8151,7 @@ int SaveEXRImageToFile(const EXRImage *exr_image, const EXRHeader *exr_header,
   return TINYEXR_SUCCESS;
 }
 
-size_t SaveEXRMultipartImageToMemory(const EXRImage* exr_images,
+TINYEXR_PUBLIC size_t SaveEXRMultipartImageToMemory(const EXRImage* exr_images,
                                      const EXRHeader** exr_headers,
                                      unsigned int num_parts,
                                      unsigned char** memory_out, const char** err) {
@@ -8215,7 +8221,7 @@ int SaveEXRMultipartImageToFile(const EXRImage* exr_images,
   return TINYEXR_SUCCESS;
 }
 
-int LoadDeepEXR(DeepImage *deep_image, const char *filename, const char **err) {
+TINYEXR_PUBLIC int LoadDeepEXR(DeepImage *deep_image, const char *filename, const char **err) {
   if (deep_image == NULL) {
     tinyexr::SetErrorMessage("Invalid argument for LoadDeepEXR", err);
     return TINYEXR_ERROR_INVALID_ARGUMENT;
@@ -8569,7 +8575,7 @@ int LoadDeepEXR(DeepImage *deep_image, const char *filename, const char **err) {
   return TINYEXR_SUCCESS;
 }
 
-void InitEXRImage(EXRImage *exr_image) {
+TINYEXR_PUBLIC void InitEXRImage(EXRImage *exr_image) {
   if (exr_image == NULL) {
     return;
   }
@@ -8587,14 +8593,14 @@ void InitEXRImage(EXRImage *exr_image) {
   exr_image->num_tiles = 0;
 }
 
-void FreeEXRErrorMessage(const char *msg) {
+TINYEXR_PUBLIC void FreeEXRErrorMessage(const char *msg) {
   if (msg) {
     free(reinterpret_cast<void *>(const_cast<char *>(msg)));
   }
   return;
 }
 
-void InitEXRHeader(EXRHeader *exr_header) {
+TINYEXR_PUBLIC void InitEXRHeader(EXRHeader *exr_header) {
   if (exr_header == NULL) {
     return;
   }
@@ -8602,7 +8608,7 @@ void InitEXRHeader(EXRHeader *exr_header) {
   memset(exr_header, 0, sizeof(EXRHeader));
 }
 
-int FreeEXRHeader(EXRHeader *exr_header) {
+TINYEXR_PUBLIC int FreeEXRHeader(EXRHeader *exr_header) {
   if (exr_header == NULL) {
     return TINYEXR_ERROR_INVALID_ARGUMENT;
   }
@@ -8634,7 +8640,7 @@ int FreeEXRHeader(EXRHeader *exr_header) {
   return TINYEXR_SUCCESS;
 }
 
-void EXRSetNameAttr(EXRHeader* exr_header, const char* name) {
+TINYEXR_PUBLIC void EXRSetNameAttr(EXRHeader* exr_header, const char* name) {
   if (exr_header == NULL) {
     return;
   }
@@ -8647,7 +8653,7 @@ void EXRSetNameAttr(EXRHeader* exr_header, const char* name) {
   }
 }
 
-int EXRNumLevels(const EXRImage* exr_image) {
+TINYEXR_PUBLIC int EXRNumLevels(const EXRImage* exr_image) {
   if (exr_image == NULL) return 0;
   if(exr_image->images) return 1; // scanlines
   int levels = 1;
@@ -8656,7 +8662,7 @@ int EXRNumLevels(const EXRImage* exr_image) {
   return levels;
 }
 
-int FreeEXRImage(EXRImage *exr_image) {
+TINYEXR_PUBLIC int FreeEXRImage(EXRImage *exr_image) {
   if (exr_image == NULL) {
     return TINYEXR_ERROR_INVALID_ARGUMENT;
   }
@@ -8693,7 +8699,7 @@ int FreeEXRImage(EXRImage *exr_image) {
   return TINYEXR_SUCCESS;
 }
 
-int ParseEXRHeaderFromFile(EXRHeader *exr_header, const EXRVersion *exr_version,
+TINYEXR_PUBLIC int ParseEXRHeaderFromFile(EXRHeader *exr_header, const EXRVersion *exr_version,
                            const char *filename, const char **err) {
   if (exr_header == NULL || exr_version == NULL || filename == NULL) {
     tinyexr::SetErrorMessage("Invalid argument for ParseEXRHeaderFromFile",
@@ -8711,7 +8717,7 @@ int ParseEXRHeaderFromFile(EXRHeader *exr_header, const EXRVersion *exr_version,
                                   err);
 }
 
-int ParseEXRMultipartHeaderFromMemory(EXRHeader ***exr_headers,
+TINYEXR_PUBLIC int ParseEXRMultipartHeaderFromMemory(EXRHeader ***exr_headers,
                                       int *num_headers,
                                       const EXRVersion *exr_version,
                                       const unsigned char *memory, size_t size,
@@ -8823,7 +8829,7 @@ int ParseEXRMultipartHeaderFromMemory(EXRHeader ***exr_headers,
   return retcode;
 }
 
-int ParseEXRMultipartHeaderFromFile(EXRHeader ***exr_headers, int *num_headers,
+TINYEXR_PUBLIC int ParseEXRMultipartHeaderFromFile(EXRHeader ***exr_headers, int *num_headers,
                                     const EXRVersion *exr_version,
                                     const char *filename, const char **err) {
   if (exr_headers == NULL || num_headers == NULL || exr_version == NULL ||
@@ -8843,7 +8849,7 @@ int ParseEXRMultipartHeaderFromFile(EXRHeader ***exr_headers, int *num_headers,
       exr_headers, num_headers, exr_version, file.data, file.size, err);
 }
 
-int ParseEXRVersionFromMemory(EXRVersion *version, const unsigned char *memory,
+TINYEXR_PUBLIC int ParseEXRVersionFromMemory(EXRVersion *version, const unsigned char *memory,
                               size_t size) {
   if (version == NULL || memory == NULL) {
     return TINYEXR_ERROR_INVALID_ARGUMENT;
@@ -8900,7 +8906,7 @@ int ParseEXRVersionFromMemory(EXRVersion *version, const unsigned char *memory,
   return TINYEXR_SUCCESS;
 }
 
-int ParseEXRVersionFromFile(EXRVersion *version, const char *filename) {
+TINYEXR_PUBLIC int ParseEXRVersionFromFile(EXRVersion *version, const char *filename) {
   if (filename == NULL) {
     return TINYEXR_ERROR_INVALID_ARGUMENT;
   }
@@ -8939,7 +8945,7 @@ int ParseEXRVersionFromFile(EXRVersion *version, const char *filename) {
   return ParseEXRVersionFromMemory(version, buf, tinyexr::kEXRVersionSize);
 }
 
-int LoadEXRMultipartImageFromMemory(EXRImage *exr_images,
+TINYEXR_PUBLIC int LoadEXRMultipartImageFromMemory(EXRImage *exr_images,
                                     const EXRHeader **exr_headers,
                                     unsigned int num_parts,
                                     const unsigned char *memory,
@@ -9070,7 +9076,7 @@ int LoadEXRMultipartImageFromMemory(EXRImage *exr_images,
   return TINYEXR_SUCCESS;
 }
 
-int LoadEXRMultipartImageFromFile(EXRImage *exr_images,
+TINYEXR_PUBLIC int LoadEXRMultipartImageFromFile(EXRImage *exr_images,
                                   const EXRHeader **exr_headers,
                                   unsigned int num_parts, const char *filename,
                                   const char **err) {
@@ -9090,7 +9096,7 @@ int LoadEXRMultipartImageFromFile(EXRImage *exr_images,
                                          file.data, file.size, err);
 }
 
-int SaveEXRToMemory(const float *data, int width, int height, int components,
+TINYEXR_PUBLIC int SaveEXRToMemory(const float *data, int width, int height, int components,
             const int save_as_fp16, unsigned char **outbuf, const char **err) {
 
   if ((components == 1) || components == 3 || components == 4) {
@@ -9246,7 +9252,7 @@ int SaveEXRToMemory(const float *data, int width, int height, int components,
   return int(mem_size);
 }
 
-int SaveEXR(const float *data, int width, int height, int components,
+TINYEXR_PUBLIC int SaveEXR(const float *data, int width, int height, int components,
             const int save_as_fp16, const char *outfilename, const char **err) {
   if ((components == 1) || components == 3 || components == 4) {
     // OK
