Resync

Author: LibretroAdmin

formats/cdfs/cdfs.c

@@ -32,10 +32,10 @@ static void cdfs_determine_sector_size(cdfs_track_t* track)
       return;
 
    /* if this is a CDROM-XA data source, the "CD001" tag will be 25 bytes into the sector */
-   if (  buffer[25] == 0x43 
+   if (  buffer[25] == 0x43
       && buffer[26] == 0x44
-      && buffer[27] == 0x30 
-      && buffer[28] == 0x30 
+      && buffer[27] == 0x30
+      && buffer[28] == 0x30
       && buffer[29] == 0x31)
    {
       track->stream_sector_size        = 2352;
@@ -44,8 +44,8 @@ static void cdfs_determine_sector_size(cdfs_track_t* track)
    /* otherwise it should be 17 bytes into the sector */
    else if (buffer[17] == 0x43
       &&    buffer[18] == 0x44
-      &&    buffer[19] == 0x30 
-      &&    buffer[20] == 0x30 
+      &&    buffer[19] == 0x30
+      &&    buffer[20] == 0x30
       &&    buffer[21] == 0x31)
    {
       track->stream_sector_size = 2352;
@@ -65,7 +65,7 @@ static void cdfs_determine_sector_size(cdfs_track_t* track)
          && buffer[ 7] == 0xFF
          && buffer[ 8] == 0xFF
          && buffer[ 9] == 0xFF
-         && buffer[10] == 0xFF 
+         && buffer[10] == 0xFF
          && buffer[11] == 0)
       {
          /* if we didn't find a CD001 tag, this format may predate ISO-9660 */
@@ -80,21 +80,21 @@ static void cdfs_determine_sector_size(cdfs_track_t* track)
 static void cdfs_determine_sector_size_from_file_size(cdfs_track_t* track)
 {
    /* attempt to determine stream_sector_size from file size */
-   size_t size = intfstream_get_size(track->stream);
+   size_t _len = intfstream_get_size(track->stream);
 
-   if ((size % 2352) == 0)
+   if ((_len % 2352) == 0)
    {
       /* raw tracks use all 2352 bytes and have a 24 byte header */
       track->stream_sector_size        = 2352;
       track->stream_sector_header_size = 24;
    }
-   else if ((size % 2048) == 0)
+   else if ((_len % 2048) == 0)
    {
       /* cooked tracks eliminate all header/footer data */
       track->stream_sector_size        = 2048;
       track->stream_sector_header_size = 0;
    }
-   else if ((size % 2336) == 0)
+   else if ((_len % 2336) == 0)
    {
       /* MODE 2 format without 16-byte sync data */
       track->stream_sector_size        = 2336;
@@ -172,7 +172,7 @@ static int cdfs_find_file(cdfs_file_t* file, const char* path)
       intfstream_read(file->track->stream, buffer, sizeof(buffer));
 
       /* the directory_record starts at 156 bytes into the sector.
-       * the sector containing the root directory contents is a 
+       * the sector containing the root directory contents is a
        * 3 byte value that is 2 bytes into the directory_record. */
       offset = 156 + 2;
       sector = buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16);
@@ -187,25 +187,25 @@ static int cdfs_find_file(cdfs_file_t* file, const char* path)
 
    while (tmp < buffer + sizeof(buffer))
    {
-      /* The first byte of the record is the length of 
+      /* The first byte of the record is the length of
        * the record - if 0, we reached the end of the data */
       if (!*tmp)
          break;
 
-      /* filename is 33 bytes into the record and 
+      /* filename is 33 bytes into the record and
        * the format is "FILENAME;version" or "DIRECTORY" */
-      if (        (tmp[33 + path_length] == ';' 
+      if (        (tmp[33 + path_length] == ';'
                || (tmp[33 + path_length] == '\0'))
                &&  strncasecmp((const char*)(tmp + 33), path, path_length) == 0)
       {
          /* the file size is in bytes 10-13 of the record */
-         file->size = 
+         file->size =
               (tmp[10])
-            | (tmp[11] << 8) 
-            | (tmp[12] << 16) 
+            | (tmp[11] << 8)
+            | (tmp[12] << 16)
             | (tmp[13] << 24);
 
-         /* the file contents are in the sector identified 
+         /* the file contents are in the sector identified
           * in bytes 2-4 of the record */
          sector = tmp[2] | (tmp[3] << 8) | (tmp[4] << 16);
          return sector;
@@ -235,7 +235,7 @@ int cdfs_open_file(cdfs_file_t* file, cdfs_track_t* track, const char* path)
    {
       file->first_sector = 0;
       file->size         = (unsigned int)((intfstream_get_size(
-               file->track->stream) / file->track->stream_sector_size) 
+               file->track->stream) / file->track->stream_sector_size)
          * 2048);
       return 1;
    }
@@ -319,8 +319,8 @@ int64_t cdfs_read_file(cdfs_file_t* file, void* buffer, uint64_t len)
 
 void cdfs_close_file(cdfs_file_t* file)
 {
-   /* Not really anything to do here, just 
-    * clear out the first_sector so 
+   /* Not really anything to do here, just
+    * clear out the first_sector so
     * read() won't do anything */
    if (file)
       file->first_sector = -1;
@@ -461,7 +461,7 @@ static cdfs_track_t* cdfs_open_cue_track(
             while (file_end > file && *file_end != ' ' && *file_end != '\t')
                --file_end;
 
-            if (     file[0]      == '"' 
+            if (     file[0]      == '"'
                   && file_end[-1] == '"')
             {
                ++file;

formats/libchdr/libchdr_chd.c

@@ -1568,14 +1568,14 @@ static chd_error hunk_read_into_cache(chd_file *chd, UINT32 hunknum)
     hunk
 -------------------------------------------------*/
 
-static UINT8* hunk_read_compressed(chd_file *chd, UINT64 offset, size_t size)
+static UINT8* hunk_read_compressed(chd_file *chd, UINT64 offset, size_t len)
 {
    int64_t bytes;
    if (chd->file_cache)
       return chd->file_cache + offset;
    filestream_seek(chd->file, offset, SEEK_SET);
-   bytes = filestream_read(chd->file, chd->compressed, size);
-   if (bytes != (int64_t)size)
+   bytes = filestream_read(chd->file, chd->compressed, len);
+   if (bytes != (int64_t)len)
       return NULL;
    return chd->compressed;
 }
@@ -1585,17 +1585,17 @@ static UINT8* hunk_read_compressed(chd_file *chd, UINT64 offset, size_t size)
     hunk
 -------------------------------------------------*/
 
-static chd_error hunk_read_uncompressed(chd_file *chd, UINT64 offset, size_t size, UINT8 *dest)
+static chd_error hunk_read_uncompressed(chd_file *chd, UINT64 offset, size_t len, UINT8 *dest)
 {
    int64_t bytes;
    if (chd->file_cache)
    {
-      memcpy(dest, chd->file_cache + offset, size);
+      memcpy(dest, chd->file_cache + offset, len);
       return CHDERR_NONE;
    }
    filestream_seek(chd->file, offset, SEEK_SET);
-   bytes = filestream_read(chd->file, dest, size);
-   if (bytes != (int64_t)size)
+   bytes = filestream_read(chd->file, dest, len);
+   if (bytes != (int64_t)len)
       return CHDERR_READ_ERROR;
    return CHDERR_NONE;
 }

formats/wav/rwav.c

@@ -46,11 +46,11 @@ struct rwav_iterator
    int step;
 };
 
-void rwav_init(rwav_iterator_t* iter, rwav_t* out, const void* buf, size_t size)
+void rwav_init(rwav_iterator_t* iter, rwav_t* out, const void *s, size_t len)
 {
    iter->out    = out;
-   iter->data   = (const uint8_t*)buf;
-   iter->size   = size;
+   iter->data   = (const uint8_t*)s;
+   iter->size   = len;
    iter->step   = ITER_BEGIN;
 
    out->samples = NULL;
@@ -159,7 +159,7 @@ enum rwav_state rwav_iterate(rwav_iterator_t *iter)
    return RWAV_ITERATE_ERROR;
 }
 
-enum rwav_state rwav_load(rwav_t* out, const void* buf, size_t size)
+enum rwav_state rwav_load(rwav_t* out, const void *s, size_t len)
 {
    enum rwav_state res;
    rwav_iterator_t iter;
@@ -171,7 +171,7 @@ enum rwav_state rwav_load(rwav_t* out, const void* buf, size_t size)
    iter.j               = 0;
    iter.step            = 0;
 
-   rwav_init(&iter, out, buf, size);
+   rwav_init(&iter, out, s, len);
 
    do
    {

hash/lrc_hash.c

@@ -123,7 +123,7 @@ static void sha256_block(struct sha256_ctx *p)
 }
 
 static void sha256_chunk(struct sha256_ctx *p,
-      const uint8_t *s, unsigned len)
+      const uint8_t *s, size_t len)
 {
    p->len += len;
 
@@ -191,7 +191,7 @@ void sha256_hash(char *s, const uint8_t *in, size_t len)
    } shahash;
 
    sha256_init(&sha);
-   sha256_chunk(&sha, in, (unsigned)len);
+   sha256_chunk(&sha, in, len);
    sha256_final(&sha);
    sha256_subhash(&sha, shahash.u32);
 

include/formats/image.h

@@ -68,7 +68,7 @@ bool image_texture_color_convert(unsigned r_shift,
       struct texture_image *out_img);
 
 bool image_texture_load_buffer(struct texture_image *img,
-   enum image_type_enum type, void *buffer, size_t buffer_len);
+   enum image_type_enum type, void *s, size_t len);
 
 bool image_texture_load(struct texture_image *img, const char *path);
 void image_texture_free(struct texture_image *img);
@@ -90,8 +90,10 @@ void image_transfer_set_buffer_ptr(
 int image_transfer_process(
       void *data,
       enum image_type_enum type,
-      uint32_t **buf, size_t size,
-      unsigned *width, unsigned *height);
+      uint32_t **buf,
+      size_t len,
+      unsigned *width,
+      unsigned *height);
 
 bool image_transfer_iterate(void *data, enum image_type_enum type);
 

include/formats/rwav.h

@@ -62,7 +62,7 @@ typedef struct rwav_iterator rwav_iterator_t;
 /**
  * Initializes the iterator to fill the out structure with data parsed from buf.
  */
-void rwav_init(rwav_iterator_t* iter, rwav_t* out, const void* buf, size_t size);
+void rwav_init(rwav_iterator_t *iter, rwav_t *out, const void* buf, size_t len);
 
 /**
  * Parses a piece of the data. Continue calling as long as it returns RWAV_ITERATE_MORE.
@@ -75,7 +75,7 @@ enum rwav_state rwav_iterate(rwav_iterator_t *iter);
 /**
  * Loads the entire data in one go.
  */
-enum rwav_state rwav_load(rwav_t* out, const void* buf, size_t size);
+enum rwav_state rwav_load(rwav_t *out, const void *buf, size_t len);
 
 /**
  * Frees parsed wave data.

include/libretro.h

@@ -5365,14 +5365,14 @@ typedef bool (RETRO_CALLCONV *retro_set_initial_image_t)(unsigned index, const c
  * on the host's file system.
  *
  * @param index The index of the disk image to get the path of.
- * @param path A buffer to store the path in.
- * @param len The size of \c path, in bytes.
+ * @param s A buffer to store the path in.
+ * @param len The size of \c s, in bytes.
  * @return \c true if the disk image's location was successfully
- * queried and copied into \c path,
+ * queried and copied into \c s,
  * \c false if the index is invalid
  * or the core couldn't locate the disk image.
  */
-typedef bool (RETRO_CALLCONV *retro_get_image_path_t)(unsigned index, char *path, size_t len);
+typedef bool (RETRO_CALLCONV *retro_get_image_path_t)(unsigned index, char *s, size_t len);
 
 /**
  * Returns a friendly label for the given disk image.
@@ -5388,12 +5388,12 @@ typedef bool (RETRO_CALLCONV *retro_get_image_path_t)(unsigned index, char *path
  * so that the frontend can provide better guidance to the player.
  *
  * @param index The index of the disk image to return a label for.
- * @param label A buffer to store the resulting label in.
- * @param len The length of \c label, in bytes.
+ * @param s A buffer to store the resulting label in.
+ * @param len The length of \c s, in bytes.
  * @return \c true if the disk image at \c index is valid
- * and a label was copied into \c label.
+ * and a label was copied into \c s.
  */
-typedef bool (RETRO_CALLCONV *retro_get_image_label_t)(unsigned index, char *label, size_t len);
+typedef bool (RETRO_CALLCONV *retro_get_image_label_t)(unsigned index, char *s, size_t len);
 
 /**
  * An interface that the frontend can use to exchange disks
@@ -7705,7 +7705,7 @@ RETRO_API size_t retro_serialize_size(void);
  * @see retro_serialize_size()
  * @see retro_unserialize()
  */
-RETRO_API bool retro_serialize(void *data, size_t size);
+RETRO_API bool retro_serialize(void *data, size_t len);
 
 /**
  * Unserialize the given state data, and load it into the internal state.
@@ -7714,7 +7714,7 @@ RETRO_API bool retro_serialize(void *data, size_t size);
  *
  * @see retro_serialize()
  */
-RETRO_API bool retro_unserialize(const void *data, size_t size);
+RETRO_API bool retro_unserialize(const void *data, size_t len);
 
 /**
  * Reset all the active cheats to their default disabled state.

include/lrc_hash.h

@@ -39,13 +39,13 @@ RETRO_BEGIN_DECLS
 
 /**
  * sha256_hash:
- * @out               : Output.
+ * @s                 : Output.
  * @in                : Input.
- * @size              : Size of @out.
+ * @len               : Size of @out.
  *
  * Hashes SHA256 and outputs a human readable string.
  **/
-void sha256_hash(char *out, const uint8_t *in, size_t size);
+void sha256_hash(char *s, const uint8_t *in, size_t len);
 
 int sha1_calculate(const char *path, char *result);
 

include/retro_math.h

@@ -24,6 +24,7 @@
 #define _LIBRETRO_COMMON_MATH_H
 
 #include <stdint.h>
+#include <stdlib.h>
 
 #if defined(_WIN32) && !defined(_XBOX)
 #define WIN32_LEAN_AND_MEAN
@@ -126,7 +127,7 @@ static INLINE float saturate_value(float v)
  *
  * Returns: dot product value (derived from @a and @b).
  **/
-static INLINE float dot_product(const float* a, const float* b) 
+static INLINE float dot_product(const float* a, const float* b)
 {
    return (a[0] * b[0]) + (a[1] * b[1]) + (a[2] * b[2]);
 }
@@ -140,7 +141,7 @@ static INLINE float dot_product(const float* a, const float* b)
  *
  * Returns: Yxy colour space value (derived from @rgb).
  **/
-static INLINE void convert_rgb_to_yxy(const float* rgb, float* Yxy) 
+static INLINE void convert_rgb_to_yxy(const float* rgb, float* Yxy)
 {
    float inv;
    float xyz[3];
@@ -156,11 +157,11 @@ static INLINE void convert_rgb_to_yxy(const float* rgb, float* Yxy)
    xyz[2]              = dot_product(rgb_xyz[2], rgb);
 
    inv                 = 1.0f / dot_product(xyz, one);
-   Yxy[0]              = xyz[1]; 
+   Yxy[0]              = xyz[1];
    Yxy[1]              = xyz[0] * inv;
    Yxy[2]              = xyz[1] * inv;
 }
- 
+
 /**
  * convert_yxy_to_rgb:
  * @rgb         : in Yxy colour space value
@@ -187,4 +188,17 @@ static INLINE void convert_yxy_to_rgb(const float* Yxy, float* rgb)
    rgb[2]              = dot_product(xyz_rgb[2], xyz);
 }
 
+/**
+ * Picks a random value between a specified range.
+ *
+ * @param \c min unsigned minimum possible value.
+ * @param \c max unsigned maximum possible value.
+ *
+ * @return unsigned random value between \c min and \c max (inclusive).
+ */
+static INLINE size_t random_range(unsigned min, unsigned max)
+{
+   return (min == max) ? min : (size_t)((float)rand() / (float)RAND_MAX * (max + 1 - min) + min);
+}
+
 #endif