xine_xmalloc() deprecation: replace its use with static and non-zero size.

The xine_xmalloc() function is going to be deprecated, as its
behaviour is rarely needed as such, and it's thus misused.

With this, almost all uses of xine_xmalloc() with static size (for
instance the value returned by sizeof()) or with a size that is
guaranteed not to be zero (like strlen()+1) are replaced with calls to
either calloc(1, ...) or malloc().

malloc() is used whenever the allocated memory is going to be
immediately overwritten, while calloc() is used in every other case,
as it sets the whole memory area to zero.

--HG--
extra : transplant_source : %8F%98%EC%02%1E%83%F0s%06X%83C%205Y%80%B12%CC%E1

19 files changed, 72 insertions, 73 deletions

diff --git a/src/xine-engine/audio_out.c b/src/xine-engine/audio_out.c
index 4dcdb5af0..30756b017 100644
--- a/src/xine-engine/audio_out.c
+++ b/src/xine-engine/audio_out.c
@@ -294,7 +294,7 @@ static audio_fifo_t *fifo_new (xine_t *xine) {
 
   audio_fifo_t *fifo;
 
-  fifo = (audio_fifo_t *) xine_xmalloc (sizeof (audio_fifo_t));
+  fifo = (audio_fifo_t *) calloc(1, sizeof(audio_fifo_t));
 
   if (!fifo)
     return NULL;
@@ -2051,7 +2051,7 @@ xine_audio_port_t *_x_ao_new_port (xine_t *xine, ao_driver_t *driver,
   static const char* resample_modes[] = {"auto", "off", "on", NULL};
   static const char* av_sync_methods[] = {"metronom feedback", "resample", NULL};
 
-  this = xine_xmalloc (sizeof (aos_t)) ;
+  this = calloc(1, sizeof(aos_t)) ;
 
   this->driver                = driver;
   this->xine                  = xine;
@@ -2085,7 +2085,7 @@ xine_audio_port_t *_x_ao_new_port (xine_t *xine, ao_driver_t *driver,
   this->grab_only              = grab_only;
   this->flush_audio_driver     = 0;
   this->discard_buffers        = 0;
-  this->zero_space             = xine_xmalloc (ZERO_BUF_SIZE * 4 * 6); /* MAX as 32bit, 6 channels. */
+  this->zero_space             = calloc (1, ZERO_BUF_SIZE * 4 * 6); /* MAX as 32bit, 6 channels. */
   
   pthread_mutex_init( &this->flush_audio_driver_lock, NULL );
   pthread_cond_init( &this->flush_audio_driver_reached, NULL );
@@ -2196,8 +2196,8 @@ xine_audio_port_t *_x_ao_new_port (xine_t *xine, ao_driver_t *driver,
 
     audio_buffer_t *buf;
 
-    buf = (audio_buffer_t *) xine_xmalloc (sizeof (audio_buffer_t));
-    buf->mem = xine_xmalloc (AUDIO_BUF_SIZE);
+    buf = (audio_buffer_t *) calloc(1, sizeof(audio_buffer_t));
+    buf->mem = calloc (1, AUDIO_BUF_SIZE);
     buf->mem_size = AUDIO_BUF_SIZE;
     buf->extra_info = malloc(sizeof(extra_info_t));
     
@@ -2211,8 +2211,8 @@ xine_audio_port_t *_x_ao_new_port (xine_t *xine, ao_driver_t *driver,
 
     audio_buffer_t *buf;
 
-    buf = (audio_buffer_t *) xine_xmalloc (sizeof (audio_buffer_t));
-    buf->mem = xine_xmalloc (4*AUDIO_BUF_SIZE);
+    buf = (audio_buffer_t *) calloc(1, sizeof(audio_buffer_t));
+    buf->mem = calloc(4, AUDIO_BUF_SIZE);
     buf->mem_size = 4*AUDIO_BUF_SIZE;
     buf->extra_info = malloc(sizeof(extra_info_t));
 
diff --git a/src/xine-engine/broadcaster.c b/src/xine-engine/broadcaster.c
index 1d2f01366..5ce1619d1 100644
--- a/src/xine-engine/broadcaster.c
+++ b/src/xine-engine/broadcaster.c
@@ -323,7 +323,7 @@ broadcaster_t *_x_init_broadcaster(xine_stream_t *stream, int port)
    
   signal( SIGPIPE, SIG_IGN );
 
-  this = xine_xmalloc(sizeof(broadcaster_t));
+  this = calloc(1, sizeof(broadcaster_t));
   this->port = port;
   this->stream = stream;
   this->msock = msock;
diff --git a/src/xine-engine/buffer.c b/src/xine-engine/buffer.c
index 93ad75ba0..417fee745 100644
--- a/src/xine-engine/buffer.c
+++ b/src/xine-engine/buffer.c
@@ -500,7 +500,7 @@ fifo_buffer_t *_x_fifo_buffer_new (int num_buffers, uint32_t buf_size) {
   int            alignment = 2048;
   unsigned char *multi_buffer = NULL;
 
-  this = xine_xmalloc (sizeof (fifo_buffer_t));
+  this = calloc(1, sizeof(fifo_buffer_t));
 
   this->first               = NULL;
   this->last                = NULL;
@@ -551,7 +551,7 @@ fifo_buffer_t *_x_fifo_buffer_new (int num_buffers, uint32_t buf_size) {
   for (i = 0; i<num_buffers; i++) {
     buf_element_t *buf;
 
-    buf = xine_xmalloc (sizeof (buf_element_t));
+    buf = calloc(1, sizeof(buf_element_t));
 
     buf->mem = multi_buffer;
     multi_buffer += buf_size;
diff --git a/src/xine-engine/configfile.c b/src/xine-engine/configfile.c
index 2dc89f0af..ed3d2fcfb 100644
--- a/src/xine-engine/configfile.c
+++ b/src/xine-engine/configfile.c
@@ -323,7 +323,7 @@ static cfg_entry_t *config_add (config_values_t *this, const char *key, int exp_
 
   cfg_entry_t *entry;
 
-  entry = (cfg_entry_t *) xine_xmalloc (sizeof (cfg_entry_t));
+  entry = calloc (1, sizeof (cfg_entry_t));
   entry->config        = this;
   entry->key           = strdup(key);
   entry->type          = XINE_CONFIG_TYPE_UNKNOWN;
@@ -1005,7 +1005,7 @@ void xine_config_save (xine_t *xine, const char *filename) {
       char    *buf = NULL;
       size_t   rlen;
       
-      buf = (char *) xine_xmalloc(config_stat.st_size + 1);
+      buf = (char *) malloc(config_stat.st_size + 1);
       if((rlen = fread(buf, 1, config_stat.st_size, f_config)) && ((off_t)rlen == config_stat.st_size)) {
 	(void) fwrite(buf, 1, rlen, f_backup);
       }
@@ -1204,7 +1204,7 @@ config_values_t *_x_config_init (void) {
   config_values_t *this;
   pthread_mutexattr_t attr;
 
-  if (!(this = xine_xmalloc(sizeof(config_values_t)))) {
+  if (!(this = calloc(1, sizeof(config_values_t)))) {
 
     printf ("configfile: could not allocate config object\n");
     _x_abort();
diff --git a/src/xine-engine/demux.c b/src/xine-engine/demux.c
index 24ee1b86d..51ed5b39d 100644
--- a/src/xine-engine/demux.c
+++ b/src/xine-engine/demux.c
@@ -440,7 +440,7 @@ int _x_demux_read_header( input_plugin_t *input, unsigned char *buffer, off_t si
     read_size = input->read(input, buffer, size);
     input->seek(input, 0, SEEK_SET);
   } else if (input->get_capabilities(input) & INPUT_CAP_PREVIEW) {
-    buf = xine_xmalloc(MAX_PREVIEW_SIZE);
+    buf = malloc(MAX_PREVIEW_SIZE);
     read_size = input->get_optional_data(input, buf, INPUT_OPTIONAL_DATA_PREVIEW);
     read_size = MIN (read_size, size);
     memcpy(buffer, buf, read_size);
diff --git a/src/xine-engine/info_helper.c b/src/xine-engine/info_helper.c
index 1ac4ed982..2d0ff4d8d 100644
--- a/src/xine-engine/info_helper.c
+++ b/src/xine-engine/info_helper.c
@@ -340,7 +340,7 @@ void _x_meta_info_set_utf8(xine_stream_t *stream, int info, const char *str) {
 void _x_meta_info_n_set(xine_stream_t *stream, int info, const char *buf, int len) {
   pthread_mutex_lock(&stream->meta_mutex);
   if(meta_valid(info) && len) {
-    char *str = xine_xmalloc(len + 1);
+    char *str = malloc(len + 1);
     
     snprintf(str, len + 1 , "%s", buf);
     meta_info_set_unlocked(stream, info, (const char *) &str[0]);
@@ -376,7 +376,7 @@ void _x_meta_info_set_multi(xine_stream_t *stream, int info, ...) {
     if(len) {
       char *p, *meta;
       
-      p = meta = (char *) xine_xmalloc(len + 1);
+      p = meta = (char *) malloc(len + 1);
       
       n = 0;
       while(args[n]) {
diff --git a/src/xine-engine/input_cache.c b/src/xine-engine/input_cache.c
index 30b1ba4aa..242449b9f 100644
--- a/src/xine-engine/input_cache.c
+++ b/src/xine-engine/input_cache.c
@@ -356,7 +356,7 @@ input_plugin_t *_x_cache_plugin_get_instance (xine_stream_t *stream, int readahe
 
   lprintf("mrl: %s\n", main_plugin->get_mrl(main_plugin));
 
-  this = (cache_input_plugin_t *)xine_xmalloc(sizeof(cache_input_plugin_t));
+  this = calloc(1, sizeof(cache_input_plugin_t));
   if (!this)
     return NULL;
   
diff --git a/src/xine-engine/input_rip.c b/src/xine-engine/input_rip.c
index 0c185aa1b..200721dca 100644
--- a/src/xine-engine/input_rip.c
+++ b/src/xine-engine/input_rip.c
@@ -585,7 +585,7 @@ input_plugin_t *_x_rip_plugin_get_instance (xine_stream_t *stream, const char *f
     return NULL;
   }
 
-  this = (rip_input_plugin_t *)xine_xmalloc(sizeof(rip_input_plugin_t));
+  this = calloc(1, sizeof(rip_input_plugin_t));
   this->main_input_plugin = main_plugin;
   this->stream            = stream;
   this->curpos  = 0;
diff --git a/src/xine-engine/load_plugins.c b/src/xine-engine/load_plugins.c
index b8471e907..fce31baca 100644
--- a/src/xine-engine/load_plugins.c
+++ b/src/xine-engine/load_plugins.c
@@ -325,8 +325,8 @@ static void _insert_node (xine_t *this,
     return;
   }
 
-  entry = xine_xmalloc(sizeof(plugin_node_t));
-  entry->info         = xine_xmalloc(sizeof(plugin_info_t));
+  entry = calloc(1, sizeof(plugin_node_t));
+  entry->info         = calloc(1, sizeof(plugin_info_t));
   *(entry->info)      = *info;
   entry->info->id     = strdup(info->id);
   entry->info->init   = info->init;
@@ -339,7 +339,7 @@ static void _insert_node (xine_t *this,
 
   case PLUGIN_VIDEO_OUT:
     vo_old = info->special_info;
-    vo_new = xine_xmalloc(sizeof(vo_info_t));
+    vo_new = calloc(1, sizeof(vo_info_t));
     entry->priority = vo_new->priority = vo_old->priority;
     vo_new->visual_type = vo_old->visual_type;
     entry->info->special_info = vo_new;
@@ -347,7 +347,7 @@ static void _insert_node (xine_t *this,
 
   case PLUGIN_AUDIO_OUT:
     ao_old = info->special_info;
-    ao_new = xine_xmalloc(sizeof(ao_info_t));
+    ao_new = calloc(1, sizeof(ao_info_t));
     entry->priority = ao_new->priority = ao_old->priority;
     entry->info->special_info = ao_new;
     break;
@@ -356,7 +356,7 @@ static void _insert_node (xine_t *this,
   case PLUGIN_VIDEO_DECODER:
   case PLUGIN_SPU_DECODER:
     decoder_old = info->special_info;
-    decoder_new = xine_xmalloc(sizeof(decoder_info_t));
+    decoder_new = calloc(1, sizeof(decoder_info_t));
     if (decoder_old == NULL) {
       if (file)
 	xprintf (this, XINE_VERBOSITY_DEBUG,
@@ -369,7 +369,7 @@ static void _insert_node (xine_t *this,
       _x_abort();
     }
     for (i=0; decoder_old->supported_types[i] != 0; ++i);
-    types = xine_xmalloc((i+1)*sizeof(uint32_t));
+    types = calloc((i+1), sizeof(uint32_t));
     for (i=0; decoder_old->supported_types[i] != 0; ++i){
       types[i] = decoder_old->supported_types[i];
     }
@@ -402,14 +402,14 @@ static void _insert_node (xine_t *this,
   
   case PLUGIN_POST:
     post_old = info->special_info;
-    post_new = xine_xmalloc(sizeof(post_info_t));
+    post_new = calloc(1, sizeof(post_info_t));
     post_new->type = post_old->type;
     entry->info->special_info = post_new;
     break;
     
   case PLUGIN_DEMUX:
     demux_old = info->special_info;
-    demux_new = xine_xmalloc(sizeof(demuxer_info_t));
+    demux_new = calloc(1, sizeof(demuxer_info_t));
     
     if (demux_old) {
       entry->priority = demux_new->priority = demux_old->priority;
@@ -426,7 +426,7 @@ static void _insert_node (xine_t *this,
 
   case PLUGIN_INPUT:
     input_old = info->special_info;
-    input_new = xine_xmalloc(sizeof(input_info_t));
+    input_new = calloc(1, sizeof(input_info_t));
     
     if (input_old) {
       entry->priority = input_new->priority = input_old->priority;
@@ -468,7 +468,7 @@ static plugin_catalog_t *_new_catalog(void){
   plugin_catalog_t *catalog;
   int i;
 
-  catalog = xine_xmalloc(sizeof(plugin_catalog_t));
+  catalog = calloc(1, sizeof(plugin_catalog_t));
 
   for (i = 0; i < PLUGIN_TYPE_MAX; i++) {
     catalog->plugin_lists[i] = xine_sarray_new(0, _plugin_node_comparator);
@@ -941,8 +941,8 @@ static void load_plugin_list(FILE *fp, xine_sarray_t *plugins) {
       if( node ) {
         xine_sarray_add (plugins, node);
       }
-      node                = xine_xmalloc(sizeof(plugin_node_t));
-      file                = xine_xmalloc(sizeof(plugin_file_t));
+      node                = calloc(1, sizeof(plugin_node_t));
+      file                = calloc(1, sizeof(plugin_file_t));
       node->file          = file;
       file->filename      = strdup(line+1);
       node->info          = calloc(2, sizeof(plugin_info_t));
@@ -981,34 +981,34 @@ static void load_plugin_list(FILE *fp, xine_sarray_t *plugins) {
           
             case PLUGIN_VIDEO_OUT:
               node->info->special_info = vo_info =
-                        xine_xmalloc(sizeof(vo_info_t));
+		calloc(1, sizeof(vo_info_t));
               break;
           
             case PLUGIN_AUDIO_OUT:
               node->info->special_info = ao_info =
-		             xine_xmalloc(sizeof(ao_info_t));
+		calloc(1, sizeof(ao_info_t));
               break;
           
             case PLUGIN_DEMUX:
               node->info->special_info = demuxer_info =
-		             xine_xmalloc(sizeof(demuxer_info_t));
+		calloc(1, sizeof(demuxer_info_t));
               break;
 
             case PLUGIN_INPUT:
               node->info->special_info = input_info =
-		           xine_xmalloc(sizeof(input_info_t));
+		calloc(1, sizeof(input_info_t));
               break;
 
             case PLUGIN_AUDIO_DECODER:
             case PLUGIN_VIDEO_DECODER:
             case PLUGIN_SPU_DECODER:
               node->info->special_info = decoder_info =
-                             xine_xmalloc(sizeof(decoder_info_t));
+		calloc(1, sizeof(decoder_info_t));
               break;
 	    
 	    case PLUGIN_POST:
 	      node->info->special_info = post_info =
-			  xine_xmalloc(sizeof(post_info_t));
+		calloc(1, sizeof(post_info_t));
 	      break;
           }        
           
@@ -1073,13 +1073,13 @@ static void save_catalog (xine_t *this) {
   const char *relname = CACHE_CATALOG_FILE;
   const char *dirname = CACHE_CATALOG_DIR;
     
-  cachefile = (char *) xine_xmalloc(strlen(xine_get_homedir()) + 
-                                    strlen(relname) + 2);
+  cachefile = (char *) malloc(strlen(xine_get_homedir()) + 
+			      strlen(relname) + 2);
   sprintf(cachefile, "%s/%s", xine_get_homedir(), relname);
   
   /* make sure homedir (~/.xine) exists */
-  dirfile = (char *) xine_xmalloc(strlen(xine_get_homedir()) + 
-				  strlen(dirname) + 2);
+  dirfile = (char *) malloc(strlen(xine_get_homedir()) + 
+			    strlen(dirname) + 2);
   sprintf(dirfile, "%s/%s", xine_get_homedir(), dirname);
   mkdir (dirfile, 0755);
   free (dirfile);
@@ -1107,8 +1107,8 @@ static void load_cached_catalog (xine_t *this) {
   char *cachefile;                                               
   const char *relname = CACHE_CATALOG_FILE;
     
-  cachefile = (char *) xine_xmalloc(strlen(xine_get_homedir()) + 
-                                    strlen(relname) + 2);
+  cachefile = (char *) malloc(strlen(xine_get_homedir()) + 
+			      strlen(relname) + 2);
   sprintf(cachefile, "%s/%s", xine_get_homedir(), relname);
   
   if( (fp = fopen(cachefile,"r")) != NULL ) {
diff --git a/src/xine-engine/lrb.c b/src/xine-engine/lrb.c
index 6da846a7c..6f8ac8479 100644
--- a/src/xine-engine/lrb.c
+++ b/src/xine-engine/lrb.c
@@ -30,7 +30,7 @@ lrb_t *lrb_new (int max_num_entries,
 
   lrb_t *this;
   
-  this = xine_xmalloc (sizeof (lrb_t));
+  this = calloc(1, sizeof(lrb_t));
 
   this->max_num_entries = max_num_entries;
   this->cur_num_entries = 0;
diff --git a/src/xine-engine/metronom.c b/src/xine-engine/metronom.c
index 5d3e0a12d..49ac5cdfb 100644
--- a/src/xine-engine/metronom.c
+++ b/src/xine-engine/metronom.c
@@ -175,8 +175,7 @@ static void unixscr_exit (scr_plugin_t *scr) {
 static scr_plugin_t* unixscr_init () {
   unixscr_t *this;
 
-  this = (unixscr_t *) xine_xmalloc(sizeof(unixscr_t));
-  memset(this, 0, sizeof(*this));
+  this = calloc(1, sizeof(unixscr_t));
   
   this->scr.interface_version = 3;
   this->scr.get_priority      = unixscr_get_priority;
@@ -909,7 +908,7 @@ static void metronom_clock_exit (metronom_clock_t *this) {
 
 metronom_t * _x_metronom_init (int have_video, int have_audio, xine_t *xine) {
 
-  metronom_t *this = xine_xmalloc (sizeof (metronom_t));
+  metronom_t *this = calloc(1, sizeof (metronom_t));
 
   this->set_audio_rate             = metronom_set_audio_rate;
   this->got_video_frame            = metronom_got_video_frame;
@@ -962,7 +961,7 @@ metronom_t * _x_metronom_init (int have_video, int have_audio, xine_t *xine) {
 
 metronom_clock_t *_x_metronom_clock_init(xine_t *xine)
 {
-  metronom_clock_t *this = (metronom_clock_t *) xine_xmalloc(sizeof(metronom_clock_t));
+  metronom_clock_t *this = calloc(1, sizeof(metronom_clock_t));
   int err;
   
   this->set_option           = metronom_clock_set_option;
diff --git a/src/xine-engine/osd.c b/src/xine-engine/osd.c
index ef888e7a4..5de0de2cb 100644
--- a/src/xine-engine/osd.c
+++ b/src/xine-engine/osd.c
@@ -149,7 +149,7 @@ static osd_object_t *osd_new_object (osd_renderer_t *this, int width, int height
   
   pthread_mutex_lock (&this->osd_mutex);  
   
-  osd = xine_xmalloc( sizeof(osd_object_t) );
+  osd = calloc(1, sizeof(osd_object_t));
   osd->renderer = this;
   osd->next = this->osds;
   this->osds = osd;
@@ -670,7 +670,7 @@ static int osd_renderer_load_font(osd_renderer_t *this, char *filename) {
   /* fixme: check for all read errors... */
   if( (fp = gzopen(filename,"rb")) != NULL ) {
 
-    font = xine_xmalloc( sizeof(osd_font_t) );
+    font = calloc(1, sizeof(osd_font_t));
 
     gzread(fp, font->name, sizeof(font->name) );
     font->version = gzread_i16(fp);
@@ -818,7 +818,7 @@ static int osd_renderer_unload_font(osd_renderer_t *this, char *fontname ) {
 #ifdef HAVE_FT2
 static int osd_set_font_freetype2( osd_object_t *osd, const char *fontname, int size ) {
   if (!osd->ft2) {
-    osd->ft2 = xine_xmalloc(sizeof(osd_ft2context_t));
+    osd->ft2 = calloc(1, sizeof(osd_ft2context_t));
     if(FT_Init_FreeType( &osd->ft2->library )) {
       xprintf(osd->renderer->stream->xine, XINE_VERBOSITY_LOG,
 	      _("osd: cannot initialize ft2 library\n"));
@@ -1413,7 +1413,7 @@ static void osd_preload_fonts (osd_renderer_t *this, char *path) {
 	  char        *pathname;
 
           *p++ = '\0';
-          font = xine_xmalloc( sizeof(osd_font_t) );
+          font = calloc(1, sizeof(osd_font_t) );
           
           strncpy(font->name, s, sizeof(font->name));
           font->size = atoi(p);
@@ -1421,7 +1421,7 @@ static void osd_preload_fonts (osd_renderer_t *this, char *path) {
           lprintf("font '%s' size %d is preloaded\n", 
                   font->name, font->size);
 
-          pathname = (char *) xine_xmalloc(strlen(path) + strlen(entry->d_name) + 2);
+          pathname = malloc(strlen(path) + strlen(entry->d_name) + 2);
           sprintf (pathname, "%s/%s", path, entry->d_name);
           font->filename = pathname;
           
@@ -1579,9 +1579,9 @@ osd_renderer_t *_x_osd_renderer_init( xine_stream_t *stream ) {
   osd_renderer_t *this;
   char str[1024];
 
-  this = xine_xmalloc(sizeof(osd_renderer_t)); 
+  this = calloc(1, sizeof(osd_renderer_t)); 
   this->stream = stream;
-  this->event.object.overlay = xine_xmalloc( sizeof(vo_overlay_t) );
+  this->event.object.overlay = calloc(1, sizeof(vo_overlay_t));
 
   pthread_mutex_init (&this->osd_mutex, NULL);
 
diff --git a/src/xine-engine/post.c b/src/xine-engine/post.c
index 5d8d67037..4d8032bc0 100644
--- a/src/xine-engine/post.c
+++ b/src/xine-engine/post.c
@@ -207,7 +207,7 @@ static int post_video_rewire(xine_post_out_t *output_gen, void *data) {
 
 post_video_port_t *_x_post_intercept_video_port(post_plugin_t *post, xine_video_port_t *original,
 						post_in_t **input, post_out_t **output) {
-  post_video_port_t *port = (post_video_port_t *)xine_xmalloc(sizeof(post_video_port_t));
+  post_video_port_t *port = calloc(1, sizeof(post_video_port_t));
   
   if (!port)
     return NULL;
@@ -235,7 +235,7 @@ post_video_port_t *_x_post_intercept_video_port(post_plugin_t *post, xine_video_
   pthread_mutex_init(&port->free_frames_lock, NULL);
   
   if (input) {
-    *input = (post_in_t *)xine_xmalloc(sizeof(post_in_t));
+    *input = calloc(1, sizeof(post_in_t));
     if (!*input) return port;
     (*input)->xine_in.name = "video in";
     (*input)->xine_in.type = XINE_POST_DATA_VIDEO;
@@ -245,7 +245,7 @@ post_video_port_t *_x_post_intercept_video_port(post_plugin_t *post, xine_video_
   }
   
   if (output) {
-    *output = (post_out_t *)xine_xmalloc(sizeof(post_out_t));
+    *output = calloc(1, sizeof(post_out_t));
     if (!*output) return port;
     (*output)->xine_out.name = "video out";
     (*output)->xine_out.type = XINE_POST_DATA_VIDEO;
@@ -353,7 +353,7 @@ vo_frame_t *_x_post_intercept_video_frame(vo_frame_t *frame, post_video_port_t *
     new_frame = port->free_frame_slots;
     port->free_frame_slots = new_frame->next;
   } else {
-    new_frame = (vo_frame_t *)xine_xmalloc(sizeof(vo_frame_t));
+    new_frame = calloc(1, sizeof(vo_frame_t));
   }
   pthread_mutex_unlock(&port->free_frames_lock);
   
@@ -716,7 +716,7 @@ static int post_audio_rewire(xine_post_out_t *output_gen, void *data) {
 
 post_audio_port_t *_x_post_intercept_audio_port(post_plugin_t *post, xine_audio_port_t *original,
 						post_in_t **input, post_out_t **output) {
-  post_audio_port_t *port = (post_audio_port_t *)xine_xmalloc(sizeof(post_audio_port_t));
+  post_audio_port_t *port = calloc(1, sizeof(post_audio_port_t));
   
   if (!port)
     return NULL;
@@ -739,7 +739,7 @@ post_audio_port_t *_x_post_intercept_audio_port(post_plugin_t *post, xine_audio_
   pthread_mutex_init(&port->usage_lock, NULL);
   
   if (input) {
-    *input = (post_in_t *)xine_xmalloc(sizeof(post_in_t));
+    *input = calloc(1, sizeof(post_in_t));
     if (!*input) return port;
     (*input)->xine_in.name = "audio in";
     (*input)->xine_in.type = XINE_POST_DATA_AUDIO;
@@ -749,7 +749,7 @@ post_audio_port_t *_x_post_intercept_audio_port(post_plugin_t *post, xine_audio_
   }
   
   if (output) {
-    *output = (post_out_t *)xine_xmalloc(sizeof(post_out_t));
+    *output = calloc(1, sizeof(post_out_t));
     if (!*output) return port;
     (*output)->xine_out.name = "audio out";
     (*output)->xine_out.type = XINE_POST_DATA_AUDIO;
diff --git a/src/xine-engine/refcounter.c b/src/xine-engine/refcounter.c
index 539abf3ed..8e952952b 100644
--- a/src/xine-engine/refcounter.c
+++ b/src/xine-engine/refcounter.c
@@ -30,7 +30,7 @@ refcounter_t* _x_new_refcounter(void *object, void (*destructor)(void *))
 {
   refcounter_t *new_refcounter;
 
-  new_refcounter = (refcounter_t *) xine_xmalloc (sizeof (refcounter_t));
+  new_refcounter = (refcounter_t *) calloc(1, sizeof(refcounter_t));
   new_refcounter->count      = 1;
   new_refcounter->object     = object;
   new_refcounter->destructor = destructor;
diff --git a/src/xine-engine/scratch.c b/src/xine-engine/scratch.c
index 065f8fa0a..3be1c70ef 100644
--- a/src/xine-engine/scratch.c
+++ b/src/xine-engine/scratch.c
@@ -50,7 +50,7 @@ static void __attribute__((__format__(__printf__, 2, 0)))
   localtime_r (&t, &tm);
 
   if ( ! this->lines[this->cur] )
-    this->lines[this->cur] = xine_xmalloc(SCRATCH_LINE_LEN_MAX+1);
+    this->lines[this->cur] = malloc(SCRATCH_LINE_LEN_MAX+1);
   if ( ! this->lines[this->cur] )
     return;
 
@@ -106,7 +106,7 @@ static void scratch_dispose (scratch_buffer_t *this) {
 scratch_buffer_t *_x_new_scratch_buffer (int num_lines) {
   scratch_buffer_t *this;
 
-  this = xine_xmalloc (sizeof (scratch_buffer_t));
+  this = calloc(1, sizeof(scratch_buffer_t));
 
   this->lines   = calloc ((num_lines + 1), sizeof(char*));
   this->ordered = calloc ((num_lines + 1), sizeof(char*));
diff --git a/src/xine-engine/video_out.c b/src/xine-engine/video_out.c
index a8464ac40..98e2b800e 100644
--- a/src/xine-engine/video_out.c
+++ b/src/xine-engine/video_out.c
@@ -143,7 +143,7 @@ static img_buf_fifo_t *vo_new_img_buf_queue () {
 
   img_buf_fifo_t *queue;
 
-  queue = (img_buf_fifo_t *) xine_xmalloc (sizeof (img_buf_fifo_t));
+  queue = (img_buf_fifo_t *) calloc(1, sizeof(img_buf_fifo_t));
   if( queue ) {
     queue->first           = NULL;
     queue->last            = NULL;
@@ -1771,7 +1771,7 @@ xine_video_port_t *_x_vo_new_port (xine_t *xine, vo_driver_t *driver, int grabon
   int               num_frame_buffers;
 
 
-  this = xine_xmalloc (sizeof (vos_t)) ;
+  this = calloc(1, sizeof(vos_t)) ;
 
   this->xine                  = xine;
   this->clock                 = xine->clock;
diff --git a/src/xine-engine/video_overlay.c b/src/xine-engine/video_overlay.c
index c189fa56b..945df3cb9 100644
--- a/src/xine-engine/video_overlay.c
+++ b/src/xine-engine/video_overlay.c
@@ -199,7 +199,7 @@ static void video_overlay_reset (video_overlay_t *this) {
   pthread_mutex_lock (&this->events_mutex);
   for (i=0; i < MAX_EVENTS; i++) {
     if (this->events[i].event == NULL) {
-      this->events[i].event = xine_xmalloc (sizeof(video_overlay_event_t));
+      this->events[i].event = calloc(1, sizeof(video_overlay_event_t));
 #ifdef LOG_DEBUG
       printf ("video_overlay: MALLOC2: this->events[%d].event %p, len=%d\n",
 	      i,
@@ -293,7 +293,7 @@ static int32_t video_overlay_add_event(video_overlay_manager_t *this_gen,  void
 	  event->object.overlay->hili_trans[i] = OVL_MAX_OPACITY;
       }
 
-      this->events[new_event].event->object.overlay = xine_xmalloc (sizeof(vo_overlay_t));
+      this->events[new_event].event->object.overlay = calloc(1, sizeof(vo_overlay_t));
       xine_fast_memcpy(this->events[new_event].event->object.overlay, 
            event->object.overlay, sizeof(vo_overlay_t));
 
@@ -587,7 +587,7 @@ video_overlay_manager_t *_x_video_overlay_new_manager (xine_t *xine) {
 
   video_overlay_t *this;
 
-  this = (video_overlay_t *) xine_xmalloc (sizeof (video_overlay_t));
+  this = (video_overlay_t *) calloc(1, sizeof(video_overlay_t));
 
   this->xine                              = xine;
   this->video_overlay.init                = video_overlay_init;
diff --git a/src/xine-engine/xine.c b/src/xine-engine/xine.c
index 4b228304c..bbf7bf7fb 100644
--- a/src/xine-engine/xine.c
+++ b/src/xine-engine/xine.c
@@ -307,7 +307,7 @@ static void ticket_dispose(xine_ticket_t *this) {
 static xine_ticket_t *ticket_init(void) {
   xine_ticket_t *port_ticket;
   
-  port_ticket = (xine_ticket_t *) xine_xmalloc(sizeof(xine_ticket_t));
+  port_ticket = calloc(1, sizeof(xine_ticket_t));
   
   port_ticket->acquire_nonblocking  = ticket_acquire_nonblocking;
   port_ticket->acquire              = ticket_acquire;
@@ -570,7 +570,7 @@ xine_stream_t *xine_stream_new (xine_t *this,
 
   pthread_mutex_lock (&this->streams_lock);
 
-  stream = (xine_stream_t *) xine_xmalloc (sizeof (xine_stream_t)) ;
+  stream = (xine_stream_t *) calloc (1, sizeof (xine_stream_t)) ;
   stream->current_extra_info       = malloc( sizeof( extra_info_t ) );
   stream->audio_decoder_extra_info = malloc( sizeof( extra_info_t ) );
   stream->video_decoder_extra_info = malloc( sizeof( extra_info_t ) );
@@ -1545,7 +1545,7 @@ xine_t *xine_new (void) {
     int i_err;
 #endif
 
-  this = xine_xmalloc (sizeof (xine_t));
+    this = calloc(1, sizeof (xine_t));
   if (!this)
     _x_abort();
 
diff --git a/src/xine-engine/xine_interface.c b/src/xine-engine/xine_interface.c
index 50d8796e8..597608883 100644
--- a/src/xine-engine/xine_interface.c
+++ b/src/xine-engine/xine_interface.c
@@ -990,7 +990,7 @@ int _x_message(xine_stream_t *stream, int type, ...) {
   args[n] = NULL;
   
   size += sizeof(xine_ui_message_data_t) + 1;
-  data = xine_xmalloc( size );
+  data = calloc(1, size );
 
   strcpy(data->compatibility.str, "Upgrade your frontend to see the error messages");
   data->type           = type;