Fix build error on Windows after BLI_read changes

Don't use posix-only ssize_t in platform independent code.

Pull Request: https://projects.blender.org/blender/blender/pulls/113493

source/blender/blendthumb/src/blendthumb_win32.cc

@@ -102,7 +102,7 @@ struct StreamReader {
   IStream *_pStream;
 };
 
-static ssize_t stream_read(FileReader *reader, void *buffer, size_t size)
+static int64_t stream_read(FileReader *reader, void *buffer, size_t size)
 {
   StreamReader *stream = (StreamReader *)reader;
 
@@ -110,7 +110,7 @@ static ssize_t stream_read(FileReader *reader, void *buffer, size_t size)
   stream->_pStream->Read(buffer, size, &readsize);
   stream->reader.offset += readsize;
 
-  return ssize_t(readsize);
+  return int64_t(readsize);
 }
 
 static off64_t stream_seek(FileReader *reader, off64_t offset, int whence)

source/blender/blenlib/BLI_fileops.h

@@ -296,7 +296,7 @@ int BLI_access(const char *filepath, int mode) ATTR_WARN_UNUSED_RESULT ATTR_NONN
  * - Reads `size_t` bytes instead of `int` on WIN32.
  * \return the number of bytes read.
  */
-ssize_t BLI_read(int fd, void *buf, size_t nbytes);
+int64_t BLI_read(int fd, void *buf, size_t nbytes);
 
 /**
  * Returns true if the file with the specified name can be written.

source/blender/blenlib/BLI_filereader.h

@@ -29,7 +29,7 @@ extern "C" {
 
 struct FileReader;
 
-typedef ssize_t (*FileReaderReadFn)(struct FileReader *reader, void *buffer, size_t size);
+typedef int64_t (*FileReaderReadFn)(struct FileReader *reader, void *buffer, size_t size);
 typedef off64_t (*FileReaderSeekFn)(struct FileReader *reader, off64_t offset, int whence);
 typedef void (*FileReaderCloseFn)(struct FileReader *reader);
 

source/blender/blenlib/BLI_winstuff.h

@@ -65,15 +65,6 @@ extern "C" {
 
 typedef unsigned int mode_t;
 
-#ifndef _SSIZE_T_
-#  define _SSIZE_T_
-/* python uses HAVE_SSIZE_T */
-#  ifndef HAVE_SSIZE_T
-#    define HAVE_SSIZE_T 1
-typedef SSIZE_T ssize_t;
-#  endif
-#endif
-
 /** Directory reading compatibility with UNIX. */
 struct dirent {
   int d_ino;

source/blender/blenlib/intern/fileops.c

@@ -92,7 +92,7 @@ static char *windows_operation_string(FileExternalOperation operation)
 }
 #endif
 
-ssize_t BLI_read(int fd, void *buf, size_t nbytes)
+int64_t BLI_read(int fd, void *buf, size_t nbytes)
 {
   /* Define our own read as `read` is not guaranteed to read the number of bytes requested.
    * This happens rarely but was observed with larger than 2GB files on Linux, see: #113473.
@@ -100,9 +100,9 @@ ssize_t BLI_read(int fd, void *buf, size_t nbytes)
    * Even though this is a loop, the most common code-path will exit with "Success" case.
    * In the case where read more data than the file contains, it will loop twice,
    * exiting on EOF with the second iteration. */
-  ssize_t nbytes_read_total = 0;
+  int64_t nbytes_read_total = 0;
   while (true) {
-    ssize_t nbytes_read = read(fd,
+    int64_t nbytes_read = read(fd,
                                buf,
 #ifdef WIN32
                                /* Read must not exceed INT_MAX on WIN32, clamp. */
@@ -1239,7 +1239,7 @@ static int copy_single_file(const char *from, const char *to)
     /* symbolic links should be copied in special way */
     char *link_buffer;
     int need_free;
-    ssize_t link_len;
+    int64_t link_len;
 
     /* get large enough buffer to read link content */
     if ((st.st_size + 1) < sizeof(buf)) {

source/blender/blenlib/intern/filereader_file.c

@@ -25,10 +25,10 @@ typedef struct {
   int filedes;
 } RawFileReader;
 
-static ssize_t file_read(FileReader *reader, void *buffer, size_t size)
+static int64_t file_read(FileReader *reader, void *buffer, size_t size)
 {
   RawFileReader *rawfile = (RawFileReader *)reader;
-  ssize_t readsize = BLI_read(rawfile->filedes, buffer, size);
+  int64_t readsize = BLI_read(rawfile->filedes, buffer, size);
 
   if (readsize >= 0) {
     rawfile->reader.offset += readsize;

source/blender/blenlib/intern/filereader_gzip.c

@@ -24,7 +24,7 @@ typedef struct {
   size_t in_size;
 } GzipReader;
 
-static ssize_t gzip_read(FileReader *reader, void *buffer, size_t size)
+static int64_t gzip_read(FileReader *reader, void *buffer, size_t size)
 {
   GzipReader *gzip = (GzipReader *)reader;
 
@@ -54,7 +54,7 @@ static ssize_t gzip_read(FileReader *reader, void *buffer, size_t size)
     }
   }
 
-  ssize_t read_len = size - gzip->strm.avail_out;
+  int64_t read_len = size - gzip->strm.avail_out;
   gzip->reader.offset += read_len;
   return read_len;
 }

source/blender/blenlib/intern/filereader_memory.c

@@ -23,7 +23,7 @@ typedef struct {
   size_t length;
 } MemoryReader;
 
-static ssize_t memory_read_raw(FileReader *reader, void *buffer, size_t size)
+static int64_t memory_read_raw(FileReader *reader, void *buffer, size_t size)
 {
   MemoryReader *mem = (MemoryReader *)reader;
 
@@ -87,7 +87,7 @@ FileReader *BLI_filereader_new_memory(const void *data, size_t len)
  * This avoids system call overhead and can significantly speed up file loading.
  */
 
-static ssize_t memory_read_mmap(FileReader *reader, void *buffer, size_t size)
+static int64_t memory_read_mmap(FileReader *reader, void *buffer, size_t size)
 {
   MemoryReader *mem = (MemoryReader *)reader;
 

source/blender/blenlib/intern/filereader_zstd.c

@@ -193,7 +193,7 @@ static const char *zstd_ensure_cache(ZstdReader *zstd, int frame)
   return uncompressed_data;
 }
 
-static ssize_t zstd_read_seekable(FileReader *reader, void *buffer, size_t size)
+static int64_t zstd_read_seekable(FileReader *reader, void *buffer, size_t size)
 {
   ZstdReader *zstd = (ZstdReader *)reader;
 
@@ -244,7 +244,7 @@ static off64_t zstd_seek(FileReader *reader, off64_t offset, int whence)
   return zstd->reader.offset;
 }
 
-static ssize_t zstd_read(FileReader *reader, void *buffer, size_t size)
+static int64_t zstd_read(FileReader *reader, void *buffer, size_t size)
 {
   ZstdReader *zstd = (ZstdReader *)reader;
   ZSTD_outBuffer output = {buffer, size, 0};
@@ -253,7 +253,7 @@ static ssize_t zstd_read(FileReader *reader, void *buffer, size_t size)
     if (zstd->in_buf.pos == zstd->in_buf.size) {
       /* Ran out of buffered input data, read some more. */
       zstd->in_buf.pos = 0;
-      ssize_t readsize = zstd->base->read(
+      int64_t readsize = zstd->base->read(
           zstd->base, (char *)zstd->in_buf.src, zstd->in_buf_max_size);
 
       if (readsize > 0) {

source/blender/blenlib/intern/path_util.c

@@ -1537,7 +1537,7 @@ bool BLI_path_extension_ensure(char *path, size_t path_maxncpy, const char *ext)
 
   const size_t path_len = strlen(path);
   const size_t ext_len = strlen(ext);
-  ssize_t a;
+  int64_t a;
 
   for (a = path_len - 1; a >= 0; a--) {
     if (path[a] == '.') {

source/blender/blenloader/intern/readfile.cc

@@ -670,7 +670,7 @@ static void bh8_from_bh4(BHead *bhead, BHead4 *bhead4)
 static BHeadN *get_bhead(FileData *fd)
 {
   BHeadN *new_bhead = nullptr;
-  ssize_t readsize;
+  int64_t readsize;
 
   if (fd) {
     if (!fd->is_eof) {
@@ -922,7 +922,7 @@ AssetMetaData *blo_bhead_id_asset_data_address(const FileData *fd, const BHead *
 static void decode_blender_header(FileData *fd)
 {
   char header[SIZEOFBLENDERHEADER], num[4];
-  ssize_t readsize;
+  int64_t readsize;
 
   /* read in the header data */
   readsize = fd->file->read(fd->file, header, sizeof(header));

source/blender/blenloader/intern/undofile.cc

@@ -254,7 +254,7 @@ bool BLO_memfile_write_file(MemFile *memfile, const char *filepath)
   return true;
 }
 
-static ssize_t undo_read(FileReader *reader, void *buffer, size_t size)
+static int64_t undo_read(FileReader *reader, void *buffer, size_t size)
 {
   UndoReader *undo = (UndoReader *)reader;
 
@@ -323,7 +323,7 @@ static ssize_t undo_read(FileReader *reader, void *buffer, size_t size)
                                                                       chunk->is_identical_future;
     } while (totread < size);
 
-    return ssize_t(totread);
+    return int64_t(totread);
   }
 
   return 0;

source/blender/bmesh/intern/bmesh_operators.cc

@@ -652,7 +652,7 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slot_code, int totadd)
 {
   BMOpSlot *slot = &op->slots[slot_code];
   void *tmp;
-  ssize_t allocsize;
+  int64_t allocsize;
 
   BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
 

source/blender/imbuf/intern/util.cc

@@ -92,7 +92,7 @@ const char *imb_ext_audio[] = {
 /* OIIO will validate the entire header of some files and DPX requires 2048 */
 #define HEADER_SIZE 2048
 
-static ssize_t imb_ispic_read_header_from_filepath(const char *filepath, uchar buf[HEADER_SIZE])
+static int64_t imb_ispic_read_header_from_filepath(const char *filepath, uchar buf[HEADER_SIZE])
 {
   BLI_stat_t st;
   int fp;
@@ -114,7 +114,7 @@ static ssize_t imb_ispic_read_header_from_filepath(const char *filepath, uchar b
     return -1;
   }
 
-  const ssize_t size = BLI_read(fp, buf, HEADER_SIZE);
+  const int64_t size = BLI_read(fp, buf, HEADER_SIZE);
 
   close(fp);
   return size;
@@ -136,7 +136,7 @@ int IMB_ispic_type_from_memory(const uchar *buf, const size_t buf_size)
 int IMB_ispic_type(const char *filepath)
 {
   uchar buf[HEADER_SIZE];
-  const ssize_t buf_size = imb_ispic_read_header_from_filepath(filepath, buf);
+  const int64_t buf_size = imb_ispic_read_header_from_filepath(filepath, buf);
   if (buf_size <= 0) {
     return IMB_FTYPE_NONE;
   }
@@ -146,7 +146,7 @@ int IMB_ispic_type(const char *filepath)
 bool IMB_ispic_type_matches(const char *filepath, int filetype)
 {
   uchar buf[HEADER_SIZE];
-  const ssize_t buf_size = imb_ispic_read_header_from_filepath(filepath, buf);
+  const int64_t buf_size = imb_ispic_read_header_from_filepath(filepath, buf);
   if (buf_size <= 0) {
     return false;
   }

source/blender/windowmanager/intern/wm_playanim.cc

@@ -68,10 +68,6 @@
 
 #include "WM_api.hh" /* only for WM_main_playanim */
 
-#ifdef WIN32
-#  include "BLI_winstuff.h" /* Only for `ssize_t`. */
-#endif
-
 #ifdef WITH_AUDASPACE
 #  include <AUD_Device.h>
 #  include <AUD_Handle.h>
@@ -117,7 +113,7 @@ static bool buffer_from_filepath(const char *filepath, void **r_mem, size_t *r_s
   bool success = false;
   uchar *mem = nullptr;
   const size_t size = BLI_file_descriptor_size(file);
-  ssize_t size_read;
+  int64_t size_read;
   if (UNLIKELY(size == size_t(-1))) {
     CLOG_WARN(&LOG, "failure '%s' to access size '%s'", strerror(errno), filepath);
   }