[libexif-cvs] libexif/libexif exif-mem.c,NONE,1.1 exif-mem.h,NONE,1.1 Makefile.am,1.26,1.27 exif-content.c,1.10,1.11 exif-content.h,1.9,1.10 exif-data.c,1.48,1.49 exif-data.h,1.8,1.9 exif-entry.c,1.64,1.65 exif-entry.h,1.11,1.12 exif-loader.c,1.10,1.11 exif-loader.h,1.2,1.3

[Lutz M. <lu...@us...>]

Update of /cvsroot/libexif/libexif/libexif
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24033/libexif

Modified Files:
	Makefile.am exif-content.c exif-content.h exif-data.c 
	exif-data.h exif-entry.c exif-entry.h exif-loader.c 
	exif-loader.h 
Added Files:
	exif-mem.c exif-mem.h 
Log Message:

2004-10-02  Lutz Mueller <lu...@us...>

	* libexif/exif-mem.[c,h]: New. First attempt to offer out-sourcing
	  of memory management.


Index: exif-content.c
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/exif-content.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- exif-content.c	16 May 2004 14:06:37 -0000	1.10
+++ exif-content.c	2 Oct 2004 05:55:25 -0000	1.11
@@ -32,27 +32,46 @@
 struct _ExifContentPrivate
 {
 	unsigned int ref_count;
+
+	ExifMem *mem;
 };
 
 ExifContent *
 exif_content_new (void)
 {
 	ExifContent *content;
+	ExifMem *mem = exif_mem_new (exif_mem_alloc_func,
+			exif_mem_realloc_func, exif_mem_free_func);
 
-	content = malloc (sizeof (ExifContent));
+	content = exif_content_new_mem (mem);
+	exif_mem_unref (mem);
+
+	return content;
+}
+
+ExifContent *
+exif_content_new_mem (ExifMem *mem)
+{
+	ExifContent *content;
+
+	if (!mem) return NULL;
+
+	content = exif_mem_alloc (mem, (ExifLong) sizeof (ExifContent));
 	if (!content)
-		return (NULL);
-	memset (content, 0, sizeof (ExifContent));
-	content->priv = malloc (sizeof (ExifContentPrivate));
+		return NULL;
+	content->priv = exif_mem_alloc (mem,
+				(ExifLong) sizeof (ExifContentPrivate));
 	if (!content->priv) {
-		free (content);
-		return (NULL);
+		exif_mem_free (mem, content);
+		return NULL;
 	}
-	memset (content->priv, 0, sizeof (ExifContentPrivate));
 
 	content->priv->ref_count = 1;
 
-	return (content);
+	content->priv->mem = mem;
+	exif_mem_ref (mem);
+
+	return content;
 }
 
 void
@@ -74,11 +93,17 @@
 {
 	unsigned int i;
 
+	if (!content) return;
+
 	for (i = 0; i < content->count; i++)
 		exif_entry_unref (content->entries[i]);
-	free (content->entries);
-	free (content->priv);
-	free (content);
+	if (content->priv) {
+		ExifMem *mem = content->priv->mem;
+		exif_mem_free (mem, content->entries);
+		exif_mem_free (mem, content->priv);
+		exif_mem_free (mem, content);
+		exif_mem_unref (mem);
+	}
 }
 
 void
@@ -103,14 +128,12 @@
 void
 exif_content_add_entry (ExifContent *content, ExifEntry *entry)
 {
-	if (entry->parent)
-		return;
+	if (!content || !content->priv || !entry || entry->parent) return;
 
 	entry->parent = content;
-	content->entries = realloc (content->entries,
-				    sizeof (ExifEntry) * (content->count + 1));
-	if (!content->entries)
-	  	return;
+	content->entries = exif_mem_realloc (content->priv->mem,
+		content->entries, sizeof (ExifEntry) * (content->count + 1));
+	if (!content->entries) return;
 	content->entries[content->count] = entry;
 	exif_entry_ref (entry);
 	content->count++;
@@ -121,8 +144,7 @@
 {
 	unsigned int i;
 
-	if (!c || !e) return;
-	if (e->parent != c) return;
+	if (!c || !c->priv || !e || (e->parent != c)) return;
 
 	/* Search the entry */
 	for (i = 0; i < c->count; i++) if (c->entries[i] == e) break;
@@ -134,7 +156,8 @@
 	c->count--;
 	e->parent = NULL;
 	exif_entry_unref (e);
-	c->entries = realloc(c->entries,sizeof(ExifEntry) * c->count);
+	c->entries = exif_mem_realloc (c->priv->mem, c->entries,
+					sizeof(ExifEntry) * c->count);
 }
 
 ExifEntry *

Index: exif-loader.c
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/exif-loader.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- exif-loader.c	15 Sep 2004 16:43:53 -0000	1.10
+++ exif-loader.c	2 Oct 2004 05:55:26 -0000	1.11
@@ -29,6 +29,7 @@
 	unsigned int ref_count;
 
 	ExifLog *log;
+	ExifMem *mem;
 };
 
 static void *
@@ -36,13 +37,12 @@
 {
 	void *d;
 
-	if (!i) return NULL;
+	if (!l || !i) return NULL;
 
-	/* This is the only call to calloc in this file. */
-	d = calloc (i, 1);
+	d = exif_mem_alloc (l->mem, i);
 	if (d) return d;
 
-	if (l) EXIF_LOG_NO_MEMORY (l->log, "ExifLog", i);
+	EXIF_LOG_NO_MEMORY (l->log, "ExifLog", i);
 	return NULL;
 }
 
@@ -183,12 +183,30 @@
 ExifLoader *
 exif_loader_new (void)
 {
+	ExifLoader *l;
+	ExifMem *mem = exif_mem_new (exif_mem_alloc_func, 
+			exif_mem_realloc_func, exif_mem_free_func);
+
+	l = exif_loader_new_mem (mem);
+	exif_mem_unref (mem);
+
+	return l;
+}
+
+ExifLoader *
+exif_loader_new_mem (ExifMem *mem)
+{
 	ExifLoader *loader;
+
+	if (!mem) return NULL;
 	
-	loader = exif_loader_alloc (NULL, sizeof (ExifLoader));
+	loader = exif_mem_alloc (mem, sizeof (ExifLoader));
 	if (!loader) return NULL;
 	loader->ref_count = 1;
 
+	loader->mem = mem;
+	exif_mem_ref (mem);
+
 	return loader;
 }
 
@@ -198,21 +216,32 @@
 	if (loader) loader->ref_count++;
 }
 
+static void
+exif_loader_free (ExifLoader *loader)
+{
+	ExifMem *mem;
+
+	if (!loader) return;
+
+	mem = loader->mem;
+	exif_loader_reset (loader);
+	exif_mem_free (mem, loader);
+	exif_mem_unref (mem);
+}
+	
 void
 exif_loader_unref (ExifLoader *loader)
 {
 	if (!loader) return;
-	if (!--loader->ref_count) {
-		exif_loader_reset (loader);
-		free (loader);
-	}
+	if (!--loader->ref_count)
+		exif_loader_free (loader);
 }
 
 void
 exif_loader_reset (ExifLoader *loader)
 {
 	if (!loader) return;
-	free (loader->buf); loader->buf = NULL;
+	exif_mem_free (loader->mem, loader->buf); loader->buf = NULL;
 	loader->size = 0;
 	loader->bytes_read = 0;
 	loader->last_marker = 0;
@@ -226,7 +255,7 @@
 
 	if (!loader) return NULL;
 
-	ed = exif_data_new ();
+	ed = exif_data_new_mem (loader->mem);
 	exif_data_log (ed, loader->log);
 	exif_data_load_data (ed, loader->buf, loader->bytes_read);
 

Index: exif-data.c
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/exif-data.c,v
retrieving revision 1.48
retrieving revision 1.49
diff -u -d -r1.48 -r1.49
--- exif-data.c	17 Sep 2004 20:59:15 -0000	1.48
+++ exif-data.c	2 Oct 2004 05:55:25 -0000	1.49
@@ -51,6 +51,7 @@
 	ExifMnoteData *md;
 
 	ExifLog *log;
+	ExifMem *mem;
 
 	unsigned int ref_count;
 
@@ -63,11 +64,12 @@
 {
 	void *d;
 
-	/* This is the only call to calloc in this file. */
-	d = calloc (i, 1);
+	if (!data || !i) return NULL;
+
+	d = exif_mem_alloc (data->priv->mem, i);
 	if (d) return d;
 
-	if (data) EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i);
+	EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i);
 	return NULL;
 }
 
@@ -80,17 +82,35 @@
 ExifData *
 exif_data_new (void)
 {
+	ExifData *d;
+	ExifMem *mem = exif_mem_new (exif_mem_alloc_func,
+			exif_mem_realloc_func, exif_mem_free_func);
+
+	d = exif_data_new_mem (mem);
+	exif_mem_unref (mem);
+
+	return d;
+}
+
+ExifData *
+exif_data_new_mem (ExifMem *mem)
+{
 	ExifData *data;
 	unsigned int i;
 
-	data = exif_data_alloc (NULL, sizeof (ExifData));
+	if (!mem) return NULL;
+
+	data = exif_mem_alloc (mem, sizeof (ExifData));
 	if (!data) return (NULL);
-	data->priv = exif_data_alloc (data, sizeof (ExifDataPrivate));
-	if (!data->priv) { free (data); return (NULL); }
+	data->priv = exif_mem_alloc (mem, sizeof (ExifDataPrivate));
+	if (!data->priv) { exif_mem_free (mem, data); return (NULL); }
 	data->priv->ref_count = 1;
 
+	data->priv->mem = mem;
+	exif_mem_ref (mem);
+
 	for (i = 0; i < EXIF_IFD_COUNT; i++) {
-		data->ifd[i] = exif_content_new ();
+		data->ifd[i] = exif_content_new_mem (data->priv->mem);
 		if (!data->ifd[i]) {
 			exif_data_free (data);
 			return (NULL);
@@ -170,6 +190,8 @@
 {
 	unsigned int doff, s;
 
+	if (!data || !data->priv) return;
+
 	/*
 	 * Each entry is 12 bytes long. The memory for the entry has
 	 * already been allocated.
@@ -181,7 +203,7 @@
 
 	/* If this is the maker note tag, update it. */
 	if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
-		free (e->data);
+		exif_mem_free (data->priv->mem, e->data);
 		e->data = NULL;
 		e->size = 0;
 		exif_mnote_data_set_offset (data->priv->md, *ds - 6);
@@ -200,7 +222,7 @@
 	if (s > 4) {
 		doff = *ds - 6;
 		*ds += s;
-		*d = realloc (*d, *ds);
+		*d = exif_mem_realloc (data->priv->mem, *d, *ds);
 		if (!*d) {
 			EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", *ds);
 		  	return;
@@ -225,7 +247,7 @@
 			  (int) ds, (int) offset, (int) size);
 		return;
 	}
-	if (data->data) free (data->data);
+	if (data->data) exif_mem_free (data->priv->mem, data->data);
 	data->size = size;
 	data->data = exif_data_alloc (data, data->size);
 	if (!data->data) return;
@@ -243,6 +265,8 @@
 	unsigned int i;
 	ExifTag tag;
 
+	if (!data || !data->priv) return;
+
 	/* Read the number of entries */
 	if (offset >= ds - 1) return;
 	n = exif_get_short (d + offset, data->priv->order);
@@ -308,7 +332,7 @@
 			 * that the EXIF data does not follow the standard.
 			 */
 			if (!exif_tag_get_name (tag)) return;
-			entry = exif_entry_new ();
+			entry = exif_entry_new_mem (data->priv->mem);
 			exif_content_add_entry (ifd, entry);
 			exif_data_load_data_entry (data, entry, d, ds,
 						   offset + 12 * i);
@@ -326,8 +350,7 @@
 	unsigned int j, n_ptr = 0, n_thumb = 0;
 	ExifIfd i;
 
-	if (!data || !ifd || !d || !ds)
-		return;
+	if (!data || !data->priv || !ifd || !d || !ds) return;
 
 	for (i = 0; i < EXIF_IFD_COUNT; i++)
 		if (ifd == data->ifd[i])
@@ -370,7 +393,7 @@
 	 * and the number of entries.
 	 */
 	*ds += (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
-	*d = realloc (*d, *ds);
+	*d = exif_mem_realloc (data->priv->mem, *d, *ds);
 	if (!*d) {
 		EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", *ds);
 	  	return;
@@ -473,7 +496,7 @@
 			exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 					*ds - 6);
 			*ds += data->size;
-			*d = realloc (*d, *ds);
+			*d = exif_mem_realloc (data->priv->mem, *d, *ds);
 			if (!*d) {
 				EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData",
 						    *ds);
@@ -530,14 +553,10 @@
 	const unsigned char *d = d_orig;
 	unsigned int ds = ds_orig, len;
 
-	if (!data)
-		return;
-	if (!d || !ds)
-		return;
+	if (!data || !data->priv || !d || !ds) return;
 
-#ifdef DEBUG
-	printf ("Parsing %i byte(s) EXIF data...\n", ds);
-#endif
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+		  "Parsing %i byte(s) EXIF data...\n", ds);
 
 	/*
 	 * It can be that the data starts with the EXIF header. If it does
@@ -804,8 +823,7 @@
 {
 	unsigned int i;
 
-	if (!data)
-		return;
+	if (!data) return;
 
 	for (i = 0; i < EXIF_IFD_COUNT; i++) {
 		if (data->ifd[i]) {
@@ -813,19 +831,21 @@
 			data->ifd[i] = NULL;
 		}
 	}
-	if (data->data) {
-		free (data->data);
-		data->data = NULL;
-	}
+
 	if (data->priv) {
+		ExifMem *mem = data->priv->mem;
+		if (data->data) {
+			exif_mem_free (data->priv->mem, data->data);
+			data->data = NULL;
+		}
 		if (data->priv->md) {
 			exif_mnote_data_unref (data->priv->md);
 			data->priv->md = NULL;
 		}
-		free (data->priv);
-		data->priv = NULL;
+		exif_mem_free (mem, data->priv);
+		exif_mem_free (mem, data);
+		exif_mem_unref (mem);
 	}
-	free (data);
 }
 
 void

--- NEW FILE: exif-mem.h ---
(This appears to be a binary file; contents omitted.)

Index: Makefile.am
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/Makefile.am,v
retrieving revision 1.26
retrieving revision 1.27
diff -u -d -r1.26 -r1.27
--- Makefile.am	20 May 2004 10:50:35 -0000	1.26
+++ Makefile.am	2 Oct 2004 05:55:25 -0000	1.27
@@ -18,6 +18,7 @@
 	exif-ifd.c		\
 	exif-loader.c		\
 	exif-log.c		\
+	exif-mem.c		\
 	exif-mnote-data.c	\
 	exif-mnote-data-priv.h	\
 	exif-tag.c		\
@@ -38,6 +39,7 @@
 	exif-ifd.h		\
 	exif-loader.h		\
 	exif-log.h		\
+	exif-mem.h		\
 	exif-mnote-data.h	\
 	exif-result.h		\
 	exif-tag.h		\

Index: exif-content.h
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/exif-content.h,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- exif-content.h	7 Jan 2004 23:36:16 -0000	1.9
+++ exif-content.h	2 Oct 2004 05:55:25 -0000	1.10
@@ -31,6 +31,7 @@
 #include <libexif/exif-tag.h>
 #include <libexif/exif-entry.h>
 #include <libexif/exif-data.h>
+#include <libexif/exif-mem.h>
 
 struct _ExifContent
 {
@@ -44,10 +45,11 @@
 };
 
 /* Lifecycle */
-ExifContent *exif_content_new   (void);
-void         exif_content_ref   (ExifContent *content);
-void         exif_content_unref (ExifContent *content);
-void         exif_content_free  (ExifContent *content);
+ExifContent *exif_content_new     (void);
+ExifContent *exif_content_new_mem (ExifMem *);
+void         exif_content_ref     (ExifContent *content);
+void         exif_content_unref   (ExifContent *content);
+void         exif_content_free    (ExifContent *content);
 
 void         exif_content_add_entry     (ExifContent *content, ExifEntry *e);
 void         exif_content_remove_entry  (ExifContent *content, ExifEntry *e);

Index: exif-entry.h
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/exif-entry.h,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- exif-entry.h	17 Sep 2004 20:59:15 -0000	1.11
+++ exif-entry.h	2 Oct 2004 05:55:26 -0000	1.12
@@ -30,6 +30,7 @@
 
 #include <libexif/exif-content.h>
 #include <libexif/exif-format.h>
+#include <libexif/exif-mem.h>
 
 struct _ExifEntry {
         ExifTag tag;
@@ -46,9 +47,10 @@
 };
 
 /* Lifecycle */
-ExifEntry  *exif_entry_new   (void);
-void        exif_entry_ref   (ExifEntry *entry);
-void        exif_entry_unref (ExifEntry *entry);
+ExifEntry  *exif_entry_new     (void);
+ExifEntry  *exif_entry_new_mem (ExifMem *);
+void        exif_entry_ref     (ExifEntry *entry);
+void        exif_entry_unref   (ExifEntry *entry);
 void        exif_entry_free  (ExifEntry *entry);
 
 void        exif_entry_initialize (ExifEntry *entry, ExifTag tag);

Index: exif-loader.h
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/exif-loader.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- exif-loader.h	20 May 2004 10:50:35 -0000	1.2
+++ exif-loader.h	2 Oct 2004 05:55:26 -0000	1.3
@@ -24,6 +24,7 @@
 #include <libexif/exif-data.h>
 #include <libexif/exif-loader.h>
 #include <libexif/exif-log.h>
+#include <libexif/exif-mem.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -31,9 +32,10 @@
 
 typedef struct _ExifLoader ExifLoader;
 
-ExifLoader *exif_loader_new   (void);
-void        exif_loader_ref   (ExifLoader *);
-void        exif_loader_unref (ExifLoader *);
+ExifLoader *exif_loader_new     (void);
+ExifLoader *exif_loader_new_mem (ExifMem *);
+void        exif_loader_ref     (ExifLoader *);
+void        exif_loader_unref   (ExifLoader *);
 
 void        exif_loader_write_file (ExifLoader *, const char *fname);
 

Index: exif-entry.c
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/exif-entry.c,v
retrieving revision 1.64
retrieving revision 1.65
diff -u -d -r1.64 -r1.65
--- exif-entry.c	1 Oct 2004 12:26:17 -0000	1.64
+++ exif-entry.c	2 Oct 2004 05:55:25 -0000	1.65
@@ -39,6 +39,8 @@
 struct _ExifEntryPrivate
 {
 	unsigned int ref_count;
+
+	ExifMem *mem;
 };
 
 /* This function is hidden in exif-data.c */
@@ -63,16 +65,14 @@
 	void *d;
 	ExifLog *l = NULL;
 
-	if (!i) return NULL;
+	if (!e || !e->priv || !i) return NULL;
 
-	/* This is the only call to calloc in this file. */
-	d = calloc (i, 1);
+	d = exif_mem_alloc (e->priv->mem, i);
 	if (d) return d;
 
-	if (e && e->parent && e->parent->parent)
+	if (e->parent && e->parent->parent)
 		l = exif_data_get_log (e->parent->parent);
 	EXIF_LOG_NO_MEMORY (l, "ExifEntry", i);
-
 	return NULL;
 }
 
@@ -82,38 +82,53 @@
 	void *d;
 	ExifLog *l = NULL;
 
-	if (!i) { free (d_orig); return NULL; }
+	if (!e || !e->priv) return NULL;
 
-	/* This is the only call to realloc in this file. */
-	d = realloc (d_orig, i);
+	if (!i) { exif_mem_free (e->priv->mem, d_orig); return NULL; }
+
+	d = exif_mem_realloc (e->priv->mem, d_orig, i);
 	if (d) return d;
 
-	if (e && e->parent && e->parent->parent)
+	if (e->parent && e->parent->parent)
 		l = exif_data_get_log (e->parent->parent);
 	EXIF_LOG_NO_MEMORY (l, "ExifEntry", i);
-
 	return NULL;
 }
 
 ExifEntry *
 exif_entry_new (void)
 {
+	ExifEntry *e;
+	ExifMem *mem = exif_mem_new (exif_mem_alloc_func,
+			exif_mem_realloc_func, exif_mem_free_func);
+
+	e = exif_entry_new_mem (mem);
+	exif_mem_unref (mem);
+
+	return e;
+}
+
+ExifEntry *
+exif_entry_new_mem (ExifMem *mem)
+{
 	ExifEntry *e = NULL;
 
-	e = exif_entry_alloc (e, sizeof (ExifEntry));
+	e = exif_mem_alloc (mem, sizeof (ExifEntry));
 	if (!e) return NULL;
-	e->priv = exif_entry_alloc (e, sizeof (ExifEntryPrivate));
-	if (!e->priv) { free (e); return NULL; }
+	e->priv = exif_mem_alloc (mem, sizeof (ExifEntryPrivate));
+	if (!e->priv) { exif_mem_free (mem, e); return NULL; }
 	e->priv->ref_count = 1;
 
-	return (e);
+	e->priv->mem = mem;
+	exif_mem_ref (mem);
+
+	return e;
 }
 
 void
 exif_entry_ref (ExifEntry *e)
 {
-	if (!e)
-		return;
+	if (!e) return;
 
 	e->priv->ref_count++;
 }
@@ -121,8 +136,7 @@
 void
 exif_entry_unref (ExifEntry *e)
 {
-	if (!e)
-		return;
+	if (!e) return;
 
 	e->priv->ref_count--;
 	if (!e->priv->ref_count)
@@ -132,13 +146,16 @@
 void
 exif_entry_free (ExifEntry *e)
 {
-	if (!e)
-		return;
+	if (!e) return;
 
-	if (e->data)
-		free (e->data);
-	free (e->priv);
-	free (e);
+	if (e->priv) {
+		ExifMem *mem = e->priv->mem;
+		if (e->data)
+			exif_mem_free (mem, e->data);
+		exif_mem_free (mem, e->priv);
+		exif_mem_free (mem, e);
+		exif_mem_unref (mem);
+	}
 }
 
 void
@@ -147,7 +164,7 @@
 	unsigned int i;
 	ExifByteOrder o;
 
-	if (!e) return;
+	if (!e || !e->priv) return;
 
 	switch (e->tag) {
 	
@@ -217,7 +234,7 @@
 			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
 				"Tag 'UserComment' contained unnecessary "
 				"data which has been removed.");
-			free (e->data);
+			exif_mem_free (e->priv->mem, e->data);
 			e->data = NULL;
 			e->size = 0;
 			e->components = 0;

Index: exif-data.h
===================================================================
RCS file: /cvsroot/libexif/libexif/libexif/exif-data.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- exif-data.h	20 May 2004 10:50:35 -0000	1.8
+++ exif-data.h	2 Oct 2004 05:55:25 -0000	1.9
@@ -35,6 +35,7 @@
 
 #include <libexif/exif-content.h>
 #include <libexif/exif-mnote-data.h>
+#include <libexif/exif-mem.h>
 
 struct _ExifData
 {
@@ -46,7 +47,8 @@
 	ExifDataPrivate *priv;
 };
 
-ExifData *exif_data_new   (void);
+ExifData *exif_data_new           (void);
+ExifData *exif_data_new_mem       (ExifMem *);
 ExifData *exif_data_new_from_file (const char *path);
 ExifData *exif_data_new_from_data (const unsigned char *data,
 				   unsigned int size);

--- NEW FILE: exif-mem.c ---
#include <exif-mem.h>

#include <stdlib.h>

struct _ExifMem {
	unsigned int ref_count;
	ExifMemAllocFunc alloc_func;
	ExifMemReallocFunc realloc_func;
	ExifMemFreeFunc free_func;
};

void *
exif_mem_alloc_func (ExifLong ds)
{
	return calloc ((size_t) ds, 1);
}

void *
exif_mem_realloc_func (void *d, ExifLong ds)
{
	return realloc (d, (size_t) ds);
}

void
exif_mem_free_func (void *d)
{
	free (d);
}

ExifMem *
exif_mem_new (ExifMemAllocFunc alloc_func, ExifMemReallocFunc realloc_func,
	      ExifMemFreeFunc free_func)
{
	ExifMem *mem;

	if (!alloc_func || !realloc_func) return NULL;
	mem = alloc_func ? alloc_func (sizeof (ExifMem)) :
		           realloc_func (NULL, sizeof (ExifMem));
	if (!mem) return NULL;
	mem->ref_count = 1;

	mem->alloc_func   = alloc_func;
	mem->realloc_func = realloc_func;
	mem->free_func    = free_func;

	return mem;
}

void
exif_mem_ref (ExifMem *mem)
{
	if (!mem) return;
	mem->ref_count++;
}

void
exif_mem_unref (ExifMem *mem)
{
	if (!mem) return;
	if (!--mem->ref_count)
		exif_mem_free (mem, mem);
}

void
exif_mem_free (ExifMem *mem, void *d)
{
	if (!mem) return;
	if (mem->free_func) {
		mem->free_func (d);
		return;
	}
}

void *
exif_mem_alloc (ExifMem *mem, ExifLong ds)
{
	if (!mem) return NULL;
	if (mem->alloc_func || mem->realloc_func)
		return mem->alloc_func ? mem->alloc_func (ds) :
					 mem->realloc_func (NULL, ds);
	return NULL;
}

void *
exif_mem_realloc (ExifMem *mem, void *d, ExifLong ds)
{
	return (mem && mem->realloc_func) ? mem->realloc_func (d, ds) : NULL;
}