Another round of removing double casted malloc/calloc

Avoid double casting in more malloc() calloc() calls where appropriate.
Some formatting

Author: jenshannoschwalm

src/common/bilateral.c

@@ -175,7 +175,7 @@ dt_bilateral_t *dt_bilateral_init(const int width,     // width of input image
                                   const float sigma_s, // spatial sigma (blur pixel coords)
                                   const float sigma_r) // range sigma (blur luma values)
 {
-  dt_bilateral_t *b = (dt_bilateral_t *)malloc(sizeof(dt_bilateral_t));
+  dt_bilateral_t *b = malloc(sizeof(dt_bilateral_t));
   if(!b) return NULL;
   dt_bilateral_grid_size(b,width,height,100.0f,sigma_s,sigma_r);
   b->width = width;
@@ -222,7 +222,7 @@ void dt_bilateral_splat(const dt_bilateral_t *b, const float *const in)
     oz + oy + ox
   };
 
-  DT_OMP_FOR()  
+  DT_OMP_FOR()
   for(int slice = 0; slice < b->numslices; slice++)
   {
     const int firstrow = slice * b->sliceheight;

src/common/colorspaces.c

@@ -1396,7 +1396,7 @@ dt_colorspaces_t *dt_colorspaces_init()
 {
   cmsSetLogErrorHandler(cms_error_handler);
 
-  dt_colorspaces_t *res = (dt_colorspaces_t *)calloc(1, sizeof(dt_colorspaces_t));
+  dt_colorspaces_t *res = calloc(1, sizeof(dt_colorspaces_t));
 
   _compute_prequantized_primaries(&D65xyY, &Rec709_Primaries,
                                   &Rec709_Primaries_Prequantized);

src/common/curve_tools.c

@@ -107,7 +107,7 @@ float *d3_np_fs(int n, float a[], float b[])
       return NULL;
     }
   }
-  float *x = (float *)calloc(n, sizeof(float));
+  float *x = calloc(n, sizeof(float));
   // nc_merror(x, "d3_np_fs");
 
   for(int i = 0; i < n; i++)
@@ -265,9 +265,9 @@ static float *spline_cubic_set_internal(int n, float t[], float y[], int ibcbeg,
       return NULL;
     }
   }
-  float *a = (float *)calloc(3 * n, sizeof(float));
+  float *a = calloc(3 * n, sizeof(float));
   // nc_merror(a, "spline_cubic_set");
-  float *b = (float *)calloc(n, sizeof(float));
+  float *b = calloc(n, sizeof(float));
   // nc_merror(b, "spline_cubic_set");
   //
   //  Set up the first equation.
@@ -410,9 +410,9 @@ float *monotone_hermite_set(int n, float x[], float y[])
     }
   }
 
-  float *delta = (float *)calloc(n, sizeof(float));
+  float *delta = calloc(n, sizeof(float));
   // nc_merror(delta, "spline_cubic_set");
-  float *m = (float *)calloc(n + 1, sizeof(float));
+  float *m = calloc(n + 1, sizeof(float));
   // nc_merror(m, "spline_cubic_set");
   // calculate the slopes
   for(int i = 0; i < n - 1; i++)
@@ -484,7 +484,7 @@ float *catmull_rom_set(int n, float x[], float y[])
     }
   }
   // nc_merror(delta, "spline_cubic_set");
-  float *m = (float *)calloc(n, sizeof(float));
+  float *m = calloc(n, sizeof(float));
   // nc_merror(m, "spline_cubic_set");
 
   // calculate the slopes

src/common/dlopencl.c

@@ -86,7 +86,7 @@ dt_dlopencl_t *dt_dlopencl_init(const char *name)
     return NULL;
 
   /* now bind symbols */
-  ocl = (dt_dlopencl_t *)malloc(sizeof(dt_dlopencl_t));
+  ocl = malloc(sizeof(dt_dlopencl_t));
 
   if(ocl == NULL)
   {

src/common/dynload.c

@@ -57,7 +57,7 @@ dt_gmodule_t *dt_gmodule_open(const char *library)
 
   if(gmodule != NULL)
   {
-    module = (dt_gmodule_t *)malloc(sizeof(dt_gmodule_t));
+    module = malloc(sizeof(dt_gmodule_t));
     module->gmodule = gmodule;
     module->library = name;
   }
@@ -72,7 +72,7 @@ dt_gmodule_t *dt_gmodule_open(const char *library)
 gboolean dt_gmodule_symbol(dt_gmodule_t *module, const char *name, void (**pointer)(void))
 {
   // As in g_module_symbol() reference the returned pointer might be NULL
-  // so we also check for a non-NULL pointer for returned success 
+  // so we also check for a non-NULL pointer for returned success
   const gboolean symbol = g_module_symbol(module->gmodule, name, (gpointer)pointer);
   const gboolean valid = *pointer != NULL;
   if(!(symbol && valid))
@@ -95,7 +95,7 @@ dt_gmodule_t *dt_gmodule_open(const char *library)
 
   if(gmodule != NULL)
   {
-    module = (dt_gmodule_t *)malloc(sizeof(dt_gmodule_t));
+    module = malloc(sizeof(dt_gmodule_t));
     module->gmodule = gmodule;
     module->library = g_strdup(library);
   }

src/common/film.c

@@ -102,7 +102,7 @@ char *dt_sqlite3_escape_wildcards(const char *s)
     if (*t == '%' || *t == '_' || *t == '~')
       count++;
   }
-  char *result = (char*)malloc(count+1);
+  char *result = malloc(count+1);
   if(!result)
     return result;
   char *dest = result;

src/common/gaussian.c

@@ -171,8 +171,8 @@ dt_gaussian_t *dt_gaussian_init(const int width,    // width of input image
   g->sigma = sigma;
   g->order = order;
   g->buf = NULL;
-  g->max = (float *)calloc(channels, sizeof(float));
-  g->min = (float *)calloc(channels, sizeof(float));
+  g->max = calloc(channels, sizeof(float));
+  g->min = calloc(channels, sizeof(float));
 
   if(!g->min || !g->max) goto error;
 
@@ -828,8 +828,8 @@ dt_gaussian_cl_t *dt_gaussian_init_cl(const int devid,
   g->order = order;
   g->dev_temp1 = NULL;
   g->dev_temp2 = NULL;
-  g->max = (float *)calloc(channels, sizeof(float));
-  g->min = (float *)calloc(channels, sizeof(float));
+  g->max = calloc(channels, sizeof(float));
+  g->min = calloc(channels, sizeof(float));
 
   if(!g->min || !g->max) goto error;
 

src/common/heap.h

@@ -41,7 +41,7 @@ void heap_cleanup(heap_t *h)
 
 heap_t *heap_init(uint32_t size)
 {
-  heap_t *h = (heap_t *)malloc(sizeof(heap_t));
+  heap_t *h = malloc(sizeof(heap_t));
   if(h)
   {
     h->keys = (uint64_t *)malloc(sizeof(uint64_t) * size);

src/common/l10n.c

@@ -328,7 +328,7 @@ gchar *_l10n_get_language(const gchar *filename)
 
 dt_l10n_t *dt_l10n_init(const gchar *filename, const gboolean init_list)
 {
-  dt_l10n_t *result = (dt_l10n_t *)calloc(1, sizeof(dt_l10n_t));
+  dt_l10n_t *result = calloc(1, sizeof(dt_l10n_t));
   result->selected = -1;
   result->sys_default = -1;
 
@@ -386,7 +386,7 @@ dt_l10n_t *dt_l10n_init(const gchar *filename, const gboolean init_list)
                                            "LC_MESSAGES", GETTEXT_PACKAGE ".mo", NULL);
         if(g_file_test(testname, G_FILE_TEST_EXISTS))
         {
-          language = (dt_l10n_language_t *)calloc(1, sizeof(dt_l10n_language_t));
+          language = calloc(1, sizeof(dt_l10n_language_t));
           result->languages = g_list_prepend(result->languages, language);
 
           // some languages have a regional part in the filename, we

src/common/opencl.c

@@ -1966,7 +1966,7 @@ int dt_opencl_lock_device(const int pipetype)
   dt_pthread_mutex_lock(&cl->lock);
 
   const size_t prio_size = sizeof(int) * (cl->num_devs + 1);
-  int *priority = (int *)malloc(prio_size);
+  int *priority = malloc(prio_size);
   int mandatory;
   gboolean heavy = FALSE;
 
@@ -2110,7 +2110,7 @@ static void _opencl_md5sum(const char **files,
     }
 
     const size_t filesize = filestat.st_size;
-    char *file = (char *)malloc(filesize);
+    char *file = malloc(filesize);
 
     if(!file)
     {
@@ -2177,7 +2177,7 @@ static gboolean _opencl_load_program(const int dev,
   if(!f) return FALSE;
 
   const size_t filesize = filestat.st_size;
-  char *file = (char *)malloc(filesize + 2048);
+  char *file = malloc(filesize + 2048);
   size_t rd = fread(file, sizeof(char), filesize, f);
   fclose(f);
   if(rd != filesize)
@@ -2254,7 +2254,7 @@ static gboolean _opencl_load_program(const int dev,
         // md5sum matches, load cached binary
         size_t cached_filesize = cachedstat.st_size;
 
-        unsigned char *cached_content = (unsigned char *)malloc(cached_filesize + 1);
+        unsigned char *cached_content = malloc(cached_filesize + 1);
         rd = fread(cached_content, sizeof(char), cached_filesize, cached);
         if(rd != cached_filesize)
         {

src/common/pdf.c

@@ -277,7 +277,7 @@ static size_t _pdf_stream_encoder_Flate(dt_pdf_t *pdf, const unsigned char *data
 {
   int result;
   uLongf destLen = compressBound(len);
-  unsigned char *buffer = (unsigned char *)malloc(destLen);
+  unsigned char *buffer = malloc(destLen);
 
   result = compress(buffer, &destLen, data, len);
 
@@ -785,12 +785,12 @@ float * read_ppm(const char * filename, int * wd, int * ht)
     return NULL;
   }
 
-  float *image = (float*)malloc(sizeof(float) * width * height * 3);
+  float *image = malloc(sizeof(float) * width * height * 3);
 
   if(max <= 255)
   {
     // read a 8 bit PPM
-    uint8_t *tmp = (uint8_t *)malloc(sizeof(uint8_t) * width * height * 3);
+    uint8_t *tmp = malloc(sizeof(uint8_t) * width * height * 3);
     int res = fread(tmp, sizeof(uint8_t) * 3, width * height, f);
     if(res != width * height)
     {
@@ -809,7 +809,7 @@ float * read_ppm(const char * filename, int * wd, int * ht)
   else
   {
     // read a 16 bit PPM
-    uint16_t *tmp = (uint16_t *)malloc(sizeof(uint16_t) * width * height * 3);
+    uint16_t *tmp = malloc(sizeof(uint16_t) * width * height * 3);
     int res = fread(tmp, sizeof(uint16_t) * 3, width * height, f);
     if(res != width * height)
     {
@@ -871,7 +871,7 @@ int main(int argc, char *argv[])
     int width, height;
     float *image = read_ppm(argv[i + 1], &width, &height);
     if(!image) exit(1);
-    uint16_t *data = (uint16_t *)malloc(sizeof(uint16_t) * 3 * width * height);
+    uint16_t *data = malloc(sizeof(uint16_t) * 3 * width * height);
     if(!data)
     {
       free(image);

src/common/printprof.c

@@ -65,7 +65,7 @@ int dt_apply_printer_profile(void **in, uint32_t width, uint32_t height, int bpp
     return 1;
   }
 
-  void *out = (void *)malloc((size_t)3 * width * height);
+  void *out = malloc((size_t)3 * width * height);
 
   if(bpp == 8)
   {

src/common/pwstorage/backend_apple_keychain.c

@@ -30,7 +30,7 @@ static char* _CFStringCopyUTF8String(CFStringRef aString) {
 
   CFIndex length = CFStringGetLength(aString);
   CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
-  char *buffer = (char *)malloc(maxSize);
+  char *buffer = malloc(maxSize);
   if (CFStringGetCString(aString, buffer, maxSize, kCFStringEncodingUTF8))
   {
     return buffer;

src/common/pwstorage/backend_kwallet.c

@@ -438,7 +438,7 @@ static gchar *array2string(const gchar *pos, guint *length)
   pos += sizeof(gint);
   guint j;
 
-  gunichar2 *tmp_string = (gunichar2 *)malloc(*length);
+  gunichar2 *tmp_string = malloc(*length);
   memcpy(tmp_string, pos, *length);
 
   for(j = 0; j < ((*length) / sizeof(gunichar2)); j++)

src/common/styles.c

@@ -669,7 +669,7 @@ void dt_styles_apply_style_item(dt_develop_t *dev,
 
   if(mod_src)
   {
-    dt_iop_module_t *module = (dt_iop_module_t *)calloc(1, sizeof(dt_iop_module_t));
+    dt_iop_module_t *module = calloc(1, sizeof(dt_iop_module_t));
 
     if(module)
       module->dev = dev;

src/common/utility.c

@@ -139,7 +139,7 @@ gchar *dt_util_float_to_str(const gchar *format, const double value)
 #endif
 
   gchar *txt = g_strdup_printf(format, value);
-  
+
 #if defined(WIN32)
   _configthreadlocale(_DISABLE_PER_THREAD_LOCALE);
 #else
@@ -490,7 +490,7 @@ static cairo_surface_t *_util_get_svg_img(gchar *logo, const float size)
                 final_height = dimension.height * factor * ppd;
     const int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, final_width);
 
-    guint8 *image_buffer = (guint8 *)calloc(stride * final_height, sizeof(guint8));
+    guint8 *image_buffer = calloc(stride * final_height, sizeof(guint8));
     if(darktable.gui)
       surface = dt_cairo_image_surface_create_for_data(image_buffer, CAIRO_FORMAT_ARGB32, final_width,
                                                       final_height, stride);
@@ -906,7 +906,7 @@ char *dt_read_file(const char *const filename, size_t *filesize)
   const size_t end = ftell(fd);
   rewind(fd);
 
-  char *content = (char *)malloc(sizeof(char) * end);
+  char *content = malloc(sizeof(char) * end);
   if(!content) return NULL;
 
   const size_t count = fread(content, sizeof(char), end, fd);

src/control/crawler.c

@@ -228,7 +228,7 @@ GList *dt_control_crawler_run(void)
     while((c > image_path) && (*c != '.')) c--;
     len = c - image_path + 1;
 
-    char *extra_path = (char *)calloc(len + 3 + 1, sizeof(char));
+    char *extra_path = calloc(len + 3 + 1, sizeof(char));
     if(extra_path)
     {
       g_strlcpy(extra_path, image_path, len + 1);

src/control/jobs.c

@@ -132,7 +132,7 @@ void *dt_control_job_get_params(const _dt_job_t *job)
 dt_job_t *dt_control_job_create(dt_job_execute_callback execute,
                                 const char *msg, ...)
 {
-  _dt_job_t *job = (_dt_job_t *)calloc(1, sizeof(_dt_job_t));
+  _dt_job_t *job = calloc(1, sizeof(_dt_job_t));
   if(!job) return NULL;
 
   va_list ap;
@@ -642,8 +642,7 @@ void dt_control_jobs_init(dt_control_t *control)
   dt_pthread_mutex_unlock(&control->run_mutex);
   for(int k = 0; k < control->num_threads; k++)
   {
-    worker_thread_parameters_t *params
-        = (worker_thread_parameters_t *)calloc(1, sizeof(worker_thread_parameters_t));
+    worker_thread_parameters_t *params = calloc(1, sizeof(worker_thread_parameters_t));
     params->self = control;
     params->threadid = k;
     dt_pthread_create(&control->thread[k], _control_work, params);
@@ -656,8 +655,7 @@ void dt_control_jobs_init(dt_control_t *control)
   {
     control->job_res[k] = NULL;
     control->new_res[k] = 0;
-    worker_thread_parameters_t *params
-        = (worker_thread_parameters_t *)calloc(1, sizeof(worker_thread_parameters_t));
+    worker_thread_parameters_t *params = calloc(1, sizeof(worker_thread_parameters_t));
     params->self = control;
     params->threadid = k;
     dt_pthread_create(&control->thread_res[k], _control_work_res, params);

src/control/jobs/film_jobs.c

@@ -64,7 +64,7 @@ dt_job_t *dt_film_import1_create(dt_film_t *film)
 {
   dt_job_t *job = dt_control_job_create(&dt_film_import1_run, "cache load raw images for preview");
   if(!job) return NULL;
-  dt_film_import1_t *params = (dt_film_import1_t *)calloc(1, sizeof(dt_film_import1_t));
+  dt_film_import1_t *params = calloc(1, sizeof(dt_film_import1_t));
   if(!params)
   {
     dt_control_job_dispose(job);
@@ -101,7 +101,7 @@ dt_job_t *dt_pathlist_import_create(int argc, char *argv[])
 {
   dt_job_t *job = dt_control_job_create(&_pathlist_import_run, "import commandline images");
   if(!job) return NULL;
-  dt_film_import1_t *params = (dt_film_import1_t *)calloc(1, sizeof(dt_film_import1_t));
+  dt_film_import1_t *params = calloc(1, sizeof(dt_film_import1_t));
   if(!params)
   {
     dt_control_job_dispose(job);

src/control/jobs/image_jobs.c

@@ -50,7 +50,7 @@ dt_job_t *dt_image_load_job_create(int32_t id, dt_mipmap_size_t mip)
 {
   dt_job_t *job = dt_control_job_create(&dt_image_load_job_run, "load image %d mip %d", id, mip);
   if(!job) return NULL;
-  dt_image_load_t *params = (dt_image_load_t *)calloc(1, sizeof(dt_image_load_t));
+  dt_image_load_t *params = calloc(1, sizeof(dt_image_load_t));
   if(!params)
   {
     dt_control_job_dispose(job);
@@ -101,7 +101,7 @@ dt_job_t *dt_image_import_job_create(uint32_t filmid, const char *filename)
   dt_image_import_t *params;
   dt_job_t *job = dt_control_job_create(&dt_image_import_job_run, "import image");
   if(!job) return NULL;
-  params = (dt_image_import_t *)calloc(1, sizeof(dt_image_import_t));
+  params = calloc(1, sizeof(dt_image_import_t));
   if(!params)
   {
     dt_control_job_dispose(job);

src/control/progress.c

@@ -299,7 +299,7 @@ dt_progress_t *dt_control_progress_create(dt_control_t *control, gboolean has_pr
                                           const gchar *message)
 {
   // create the object
-  dt_progress_t *progress = (dt_progress_t *)calloc(1, sizeof(dt_progress_t));
+  dt_progress_t *progress = calloc(1, sizeof(dt_progress_t));
   dt_pthread_mutex_init(&(progress->mutex), NULL);
 
   // fill it with values