diff --git a/ext4_utils/allocate.c b/ext4_utils/allocate.c
index dfc3f16..adf91ba 100644
--- a/ext4_utils/allocate.c
+++ b/ext4_utils/allocate.c
@@ -155,8 +155,8 @@
 	if (bg->inode_table == NULL)
 		critical_error_errno("calloc");
 
-	queue_data_block(bg->inode_table, aux_info.inode_table_blocks
-			* info.block_size, block);
+	sparse_file_add_data(info.sparse_file, bg->inode_table,
+			aux_info.inode_table_blocks	* info.block_size, block);
 }
 
 void init_unused_inode_tables(void)
@@ -171,9 +171,10 @@
 			block = bg->first_block + 2;
 			if (bg->has_superblock)
 				block += aux_info.bg_desc_blocks + info.bg_desc_reserve_blocks + 1;
-			queue_fill_block(0, aux_info.inode_table_blocks * info.block_size, block);
-                }
-       }
+			sparse_file_add_fill(info.sparse_file, 0,
+					aux_info.inode_table_blocks * info.block_size, block);
+		}
+	}
 }
 
 static int bitmap_set_bit(u8 *bitmap, u32 bit)
@@ -288,7 +289,8 @@
 	u32 block = bg->first_block;
 	if (bg->has_superblock)
 		block += 1 + aux_info.bg_desc_blocks +  info.bg_desc_reserve_blocks;
-	queue_data_block(bg->bitmaps, 2 * info.block_size, block);
+	sparse_file_add_data(info.sparse_file, bg->bitmaps, 2 * info.block_size,
+			block);
 
 	bg->data_blocks_used = 0;
 	bg->free_blocks = info.blocks_per_group;
diff --git a/ext4_utils/ext2simg.c b/ext4_utils/ext2simg.c
index e8f26c6..f4b6c93 100644
--- a/ext4_utils/ext2simg.c
+++ b/ext4_utils/ext2simg.c
@@ -14,11 +14,8 @@
  * limitations under the License.
  */
 
-#include <sparse/sparse.h>
-
-#include "ext4_utils.h"
-#include "make_ext4fs.h"
-#include "allocate.h"
+#define _FILE_OFFSET_BITS 64
+#define _LARGEFILE64_SOURCE 1
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -28,6 +25,16 @@
 #include <libgen.h>
 #include <unistd.h>
 
+#include <sparse/sparse.h>
+
+#include "ext4_utils.h"
+#include "make_ext4fs.h"
+#include "allocate.h"
+
+#if defined(__APPLE__) && defined(__MACH__)
+#define off64_t off_t
+#endif
+
 #ifndef USE_MINGW /* O_BINARY is windows-specific flag */
 #define O_BINARY 0
 #endif
@@ -120,7 +127,7 @@
 		critical_error("failed to allocate block bitmap");
 
 	if (aux_info.first_data_block > 0)
-		queue_data_file(filename, 0,
+		sparse_file_add_file(info.sparse_file, filename, 0,
 				info.block_size * aux_info.first_data_block, 0);
 
 	for (i = 0; i < aux_info.groups; i++) {
@@ -145,7 +152,8 @@
 					u32 start_block = first_block + start_contiguous_block;
 					u32 len_blocks = block - start_contiguous_block;
 
-					queue_data_file(filename, (u64)info.block_size * start_block,
+					sparse_file_add_file(info.sparse_file, filename,
+							(u64)info.block_size * start_block,
 							info.block_size * len_blocks, start_block);
 					start_contiguous_block = -1;
 				}
@@ -158,7 +166,8 @@
 		if (start_contiguous_block >= 0) {
 			u32 start_block = first_block + start_contiguous_block;
 			u32 len_blocks = last_block - start_contiguous_block;
-			queue_data_file(filename, (u64)info.block_size * start_block,
+			sparse_file_add_file(info.sparse_file, filename,
+					(u64)info.block_size * start_block,
 					info.block_size * len_blocks, start_block);
 		}
 	}
@@ -222,6 +231,8 @@
 
 	read_ext(infd);
 
+	info.sparse_file = sparse_file_new(info.block_size, info.len);
+
 	build_sparse_ext(infd, in);
 
 	close(infd);
@@ -239,5 +250,7 @@
 	write_ext4_image(outfd, gzip, sparse, crc);
 	close(outfd);
 
+	sparse_file_destroy(info.sparse_file);
+
 	return 0;
 }
diff --git a/ext4_utils/ext4_utils.c b/ext4_utils/ext4_utils.c
index a210281..43b4480 100644
--- a/ext4_utils/ext4_utils.c
+++ b/ext4_utils/ext4_utils.c
@@ -83,7 +83,7 @@
 /* Write the filesystem image to a file */
 void write_ext4_image(int fd, int gz, int sparse, int crc)
 {
-	write_sparse_image(fd, gz, sparse, crc, info.block_size, info.len);
+	sparse_file_write(info.sparse_file, fd, gz, sparse, crc);
 }
 
 /* Compute the rest of the parameters of the filesystem from the basic info */
@@ -226,10 +226,10 @@
 				memcpy(aux_info.backup_sb[i], sb, info.block_size);
 				/* Update the block group nr of this backup superblock */
 				aux_info.backup_sb[i]->s_block_group_nr = i;
-				queue_data_block((u8 *)aux_info.backup_sb[i],
-                                                  info.block_size, group_start_block);
+				sparse_file_add_data(info.sparse_file, aux_info.backup_sb[i],
+						info.block_size, group_start_block);
 			}
-			queue_data_block((u8 *)aux_info.bg_desc,
+			sparse_file_add_data(info.sparse_file, aux_info.bg_desc,
 				aux_info.bg_desc_blocks * info.block_size,
 				group_start_block + 1);
 			header_size = 1 + aux_info.bg_desc_blocks + info.bg_desc_reserve_blocks;
@@ -255,9 +255,9 @@
 	if (info.block_size > 1024) {
 		u8 *buf = calloc(info.block_size, 1);
 		memcpy(buf + 1024, (u8*)aux_info.sb, 1024);
-		queue_data_block(buf, info.block_size, 0);
+		sparse_file_add_data(info.sparse_file, buf, info.block_size, 0);
 	} else {
-		queue_data_block((u8*)aux_info.sb, 1024, 1);
+		sparse_file_add_data(info.sparse_file, aux_info.sb, 1024, 1);
 	}
 }
 
diff --git a/ext4_utils/ext4_utils.h b/ext4_utils/ext4_utils.h
index 9ee6929..cad2eae 100644
--- a/ext4_utils/ext4_utils.h
+++ b/ext4_utils/ext4_utils.h
@@ -119,6 +119,8 @@
 	u32 bg_desc_reserve_blocks;
 	const char *label;
 	u8 no_journal;
+
+	struct sparse_file *sparse_file;
 };
 
 struct fs_aux_info {
diff --git a/ext4_utils/extent.c b/ext4_utils/extent.c
index 905a378..948bf41 100644
--- a/ext4_utils/extent.c
+++ b/ext4_utils/extent.c
@@ -43,7 +43,7 @@
 
 		len = min(region_len * info.block_size, backing_len);
 
-		queue_data_block(ptr, len, region_block);
+		sparse_file_add_data(info.sparse_file, ptr, len, region_block);
 		ptr += len;
 		backing_len -= len;
 	}
@@ -65,7 +65,8 @@
 
 		len = min(region_len * info.block_size, backing_len);
 
-		queue_data_file(filename, offset, len, region_block);
+		sparse_file_add_file(info.sparse_file, filename, offset, len,
+				region_block);
 		offset += len;
 		backing_len -= len;
 	}
@@ -124,7 +125,8 @@
 		if (!data)
 			critical_error_errno("calloc");
 
-		queue_data_block(data, info.block_size, extent_block);
+		sparse_file_add_data(info.sparse_file, data, info.block_size,
+				extent_block);
 
 		if (((int)(info.block_size - sizeof(struct ext4_extent_header) /
 				sizeof(struct ext4_extent))) < allocation_len) {
diff --git a/ext4_utils/indirect.c b/ext4_utils/indirect.c
index d0490f2..3d97ec8 100644
--- a/ext4_utils/indirect.c
+++ b/ext4_utils/indirect.c
@@ -46,7 +46,7 @@
 
 		len = min(region_len * info.block_size, backing_len);
 
-		queue_data_block(ptr, len, region_block);
+		sparse_file_add_data(info.sparse_file, ptr, len, region_block);
 		ptr += len;
 		backing_len -= len;
 	}
@@ -123,7 +123,8 @@
 		dind_block[i] = ind_block;
 
 		u32 *ind_block_data = calloc(info.block_size, 1);
-		queue_data_block((u8*)ind_block_data, info.block_size, ind_block);
+		sparse_file_add_data(info.sparse_file, ind_block_data, info.block_size,
+				ind_block);
 		int ind_block_len = min((int)aux_info.blocks_per_ind, len);
 
 		fill_indirect_block(ind_block_data, ind_block_len, alloc);
@@ -152,7 +153,8 @@
 		tind_block[i] = dind_block;
 
 		u32 *dind_block_data = calloc(info.block_size, 1);
-		queue_data_block((u8*)dind_block_data, info.block_size, dind_block);
+		sparse_file_add_data(info.sparse_file, dind_block_data, info.block_size,
+				dind_block);
 		int dind_block_len = min((int)aux_info.blocks_per_dind, len);
 
 		fill_dindirect_block(dind_block_data, dind_block_len, alloc);
@@ -200,7 +202,8 @@
 	}
 
 	u32 *ind_block_data = calloc(info.block_size, 1);
-	queue_data_block((u8*)ind_block_data, info.block_size, ind_block);
+	sparse_file_add_data(info.sparse_file, ind_block_data, info.block_size,
+			ind_block);
 
 	fill_indirect_block(ind_block_data, len, alloc);
 
@@ -231,7 +234,8 @@
 	}
 
 	u32 *dind_block_data = calloc(info.block_size, 1);
-	queue_data_block((u8*)dind_block_data, info.block_size, dind_block);
+	sparse_file_add_data(info.sparse_file, dind_block_data, info.block_size,
+			dind_block);
 
 	fill_dindirect_block(dind_block_data, len, alloc);
 
@@ -262,7 +266,8 @@
 	}
 
 	u32 *tind_block_data = calloc(info.block_size, 1);
-	queue_data_block((u8*)tind_block_data, info.block_size, tind_block);
+	sparse_file_add_data(info.sparse_file, tind_block_data, info.block_size,
+			tind_block);
 
 	fill_tindirect_block(tind_block_data, len, alloc);
 
@@ -441,12 +446,13 @@
 	u32 *dind_block_data = calloc(info.block_size, 1);
 	if (!dind_block_data)
 		critical_error_errno("calloc");
-	queue_data_block((u8 *)dind_block_data, info.block_size, dind_block);
+	sparse_file_add_data(info.sparse_file, dind_block_data, info.block_size,
+			dind_block);
 
 	u32 *ind_block_data = calloc(info.block_size, info.bg_desc_reserve_blocks);
 	if (!ind_block_data)
 		critical_error_errno("calloc");
-	queue_data_block((u8 *)ind_block_data,
+	sparse_file_add_data(info.sparse_file, ind_block_data,
 			info.block_size * info.bg_desc_reserve_blocks,
 			get_block(alloc, 0));
 
diff --git a/ext4_utils/libsparse/backed_block.c b/ext4_utils/libsparse/backed_block.c
index 2975b7d..2548138 100644
--- a/ext4_utils/libsparse/backed_block.c
+++ b/ext4_utils/libsparse/backed_block.c
@@ -14,20 +14,18 @@
  * limitations under the License.
  */
 
-#include <sparse/sparse.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "backed_block.h"
 #include "sparse_defs.h"
 
-#include <stdlib.h>
-#include <string.h>
-
 struct data_block {
 	u32 block;
 	u32 len;
 	void *data;
 	const char *filename;
-	off64_t offset;
+	int64_t offset;
 	struct data_block *next;
 	u32 fill_val;
 	u8 fill;
@@ -113,7 +111,7 @@
 }
 
 /* Queues a chunk of a file on disk to be written to the specified data blocks */
-void queue_data_file(const char *filename, off64_t offset, unsigned int len,
+void queue_data_file(const char *filename, int64_t offset, unsigned int len,
 		unsigned int block)
 {
 	struct data_block *db = malloc(sizeof(struct data_block));
diff --git a/ext4_utils/libsparse/backed_block.h b/ext4_utils/libsparse/backed_block.h
index bcacc55..7b7c90a 100644
--- a/ext4_utils/libsparse/backed_block.h
+++ b/ext4_utils/libsparse/backed_block.h
@@ -19,14 +19,21 @@
 
 #include <sparse/sparse.h>
 
-typedef void (*data_block_callback_t)(void *priv, off64_t off, void *data, int len);
-typedef void (*data_block_fill_callback_t)(void *priv, off64_t off, unsigned int fill_val, int len);
-typedef void (*data_block_file_callback_t)(void *priv, off64_t off,
-					   const char *file, off64_t offset,
+typedef void (*data_block_callback_t)(void *priv, int64_t off, void *data, int len);
+typedef void (*data_block_fill_callback_t)(void *priv, int64_t off, unsigned int fill_val, int len);
+typedef void (*data_block_file_callback_t)(void *priv, int64_t off,
+					   const char *file, int64_t offset,
 					   int len);
 
 void for_each_data_block(data_block_callback_t data_func,
 	data_block_file_callback_t file_func,
 	data_block_fill_callback_t fill_func, void *priv, unsigned int);
 
+void queue_data_block(void *data, unsigned int len, unsigned int block);
+void queue_fill_block(unsigned int fill_val, unsigned int len, unsigned int block);
+void queue_data_file(const char *filename, int64_t offset, unsigned int len,
+		unsigned int block);
+
+void free_data_blocks();
+
 #endif
diff --git a/ext4_utils/libsparse/include/sparse/sparse.h b/ext4_utils/libsparse/include/sparse/sparse.h
index 1109374..db06884 100644
--- a/ext4_utils/libsparse/include/sparse/sparse.h
+++ b/ext4_utils/libsparse/include/sparse/sparse.h
@@ -17,20 +17,118 @@
 #ifndef _LIBSPARSE_SPARSE_H_
 #define _LIBSPARSE_SPARSE_H_
 
-#define _FILE_OFFSET_BITS 64
-#define _LARGEFILE64_SOURCE 1
-#include <sys/types.h>
-#include <unistd.h>
+#include <stdbool.h>
+#include <stdint.h>
 
-#if defined(__APPLE__) && defined(__MACH__)
-#define off64_t off_t
-#endif
+struct sparse_file;
 
-void write_sparse_image(int fd, int gz, int sparse, int crc, unsigned int block_size, off64_t len);
-void queue_data_block(void *data, unsigned int len, unsigned int block);
-void queue_fill_block(unsigned int fill_val, unsigned int len, unsigned int block);
-void queue_data_file(const char *filename, off64_t offset, unsigned int len,
+/**
+ * sparse_file_new - create a new sparse file cookie
+ *
+ * @block_size - minimum size of a chunk
+ * @len - size of the expanded sparse file.
+ *
+ * Creates a new sparse_file cookie that can be used to associate data
+ * blocks.  Can later be written to a file with a variety of options.
+ * block_size specifies the minimum size of a chunk in the file.  The maximum
+ * size of the file is 2**32 * block_size (16TB for 4k block size).
+ *
+ * Returns the sparse file cookie, or NULL on error.
+ */
+struct sparse_file *sparse_file_new(unsigned int block_size, int64_t len);
+
+/**
+ * sparse_file_destroy - destroy a sparse file cookie
+ *
+ * @s - sparse file cookie
+ *
+ * Destroys a sparse file cookie.  After destroy, all memory passed in to
+ * sparse_file_add_data can be freed by the caller
+ */
+void sparse_file_destroy(struct sparse_file *s);
+
+/**
+ * sparse_file_add_data - associate a data chunk with a sparse file
+ *
+ * @s - sparse file cookie
+ * @data - pointer to data block
+ * @len - length of the data block
+ * @block - offset in blocks into the sparse file to place the data chunk
+ *
+ * Associates a data chunk with a sparse file cookie.  The region
+ * [block * block_size : block * block_size + len) must not already be used in
+ * the sparse file. If len is not a multiple of the block size the data
+ * will be padded with zeros.
+ *
+ * The data pointer must remain valid until the sparse file is closed or the
+ * data block is removed from the sparse file.
+ *
+ * Returns 0 on success, negative errno on error.
+ */
+int sparse_file_add_data(struct sparse_file *s,
+		void *data, unsigned int len, unsigned int block);
+
+/**
+ * sparse_file_add_fill - associate a fill chunk with a sparse file
+ *
+ * @s - sparse file cookie
+ * @fill_val - 32 bit fill data
+ * @len - length of the fill block
+ * @block - offset in blocks into the sparse file to place the fill chunk
+ *
+ * Associates a chunk filled with fill_val with a sparse file cookie.
+ * The region [block * block_size : block * block_size + len) must not already
+ * be used in the sparse file. If len is not a multiple of the block size the
+ * data will be padded with zeros.
+ *
+ * Returns 0 on success, negative errno on error.
+ */
+int sparse_file_add_fill(struct sparse_file *s,
+		uint32_t fill_val, unsigned int len, unsigned int block);
+
+/**
+ * sparse_file_add_file - associate a chunk of a file with a sparse file
+ *
+ * @s - sparse file cookie
+ * @filename - filename of the file to be copied
+ * @file_offset - offset into the copied file
+ * @len - length of the copied block
+ * @block - offset in blocks into the sparse file to place the file chunk
+ *
+ * Associates a chunk of an existing file with a sparse file cookie.
+ * The region [block * block_size : block * block_size + len) must not already
+ * be used in the sparse file. If len is not a multiple of the block size the
+ * data will be padded with zeros.
+ *
+ * Allows adding large amounts of data to a sparse file without needing to keep
+ * it all mapped.  File size is limited by available virtual address space,
+ * exceptionally large files may need to be added in multiple chunks.
+ *
+ * Returns 0 on success, negative errno on error.
+ */
+int sparse_file_add_file(struct sparse_file *s,
+		const char *filename, int64_t file_offset, unsigned int len,
 		unsigned int block);
-void free_data_blocks();
+
+/**
+ * sparse_file_write - write a sparse file to a file
+ *
+ * @s - sparse file cookie
+ * @fd - file descriptor to write to
+ * @gz - write a gzipped file
+ * @sparse - write in the Android sparse file format
+ * @crc - append a crc chunk
+ *
+ * Writes a sparse file to a file.  If gz is true, the data will be passed
+ * through zlib.  If sparse is true, the file will be written in the Android
+ * sparse file format.  If sparse is false, the file will be written by seeking
+ * over unused chunks, producing a smaller file if the filesystem supports
+ * sparse files.  If crc is true, the crc of the expanded data will be
+ * calculated and appended in a crc chunk.
+ *
+ * Returns 0 on success, negative errno on error.
+ */
+int sparse_file_write(struct sparse_file *s, int fd, bool gz, bool sparse,
+		bool crc);
 
 #endif
diff --git a/ext4_utils/libsparse/output_file.c b/ext4_utils/libsparse/output_file.c
index 6520e63..2c4b557 100644
--- a/ext4_utils/libsparse/output_file.c
+++ b/ext4_utils/libsparse/output_file.c
@@ -14,11 +14,8 @@
  * limitations under the License.
  */
 
-#include <sparse/sparse.h>
-
-#include "output_file.h"
-#include "sparse_format.h"
-#include "sparse_crc32.h"
+#define _FILE_OFFSET_BITS 64
+#define _LARGEFILE64_SOURCE 1
 
 #include <fcntl.h>
 #include <stdbool.h>
@@ -29,6 +26,10 @@
 #include <unistd.h>
 #include <zlib.h>
 
+#include "output_file.h"
+#include "sparse_format.h"
+#include "sparse_crc32.h"
+
 #ifndef USE_MINGW
 #include <sys/mman.h>
 #define O_BINARY 0
@@ -38,6 +39,7 @@
 #define lseek64 lseek
 #define ftruncate64 ftruncate
 #define mmap64 mmap
+#define off64_t off_t
 #endif
 
 #ifdef __BIONIC__
@@ -55,7 +57,7 @@
 #define CHUNK_HEADER_LEN (sizeof(chunk_header_t))
 
 struct output_file_ops {
-	int (*seek)(struct output_file *, off64_t);
+	int (*seek)(struct output_file *, int64_t);
 	int (*write)(struct output_file *, u8 *, int);
 	void (*close)(struct output_file *);
 };
@@ -65,16 +67,16 @@
 	gzFile gz_fd;
 	bool close_fd;
 	int sparse;
-	off64_t cur_out_ptr;
+	int64_t cur_out_ptr;
 	u32 chunk_cnt;
 	u32 crc32;
 	struct output_file_ops *ops;
 	int use_crc;
 	unsigned int block_size;
-	off64_t len;
+	int64_t len;
 };
 
-static int file_seek(struct output_file *out, off64_t off)
+static int file_seek(struct output_file *out, int64_t off)
 {
 	off64_t ret;
 
@@ -115,7 +117,7 @@
 	.close = file_close,
 };
 
-static int gz_file_seek(struct output_file *out, off64_t off)
+static int gz_file_seek(struct output_file *out, int64_t off)
 {
 	off64_t ret;
 
@@ -195,7 +197,7 @@
 	return 0;
 }
 
-static int write_chunk_fill(struct output_file *out, off64_t off, u32 fill_val, int len)
+static int write_chunk_fill(struct output_file *out, int64_t off, u32 fill_val, int len)
 {
 	chunk_header_t chunk_header;
 	int rnd_up_len, zero_len, count;
@@ -268,7 +270,7 @@
 	return 0;
 }
 
-static int write_chunk_raw(struct output_file *out, off64_t off, u8 *data, int len)
+static int write_chunk_raw(struct output_file *out, int64_t off, u8 *data, int len)
 {
 	chunk_header_t chunk_header;
 	int rnd_up_len, zero_len;
@@ -363,7 +365,7 @@
 	out->ops->close(out);
 }
 
-struct output_file *open_output_fd(int fd, unsigned int block_size, off64_t len,
+struct output_file *open_output_fd(int fd, unsigned int block_size, int64_t len,
 		int gz, int sparse, int chunks, int crc)
 {
 	int ret;
@@ -420,7 +422,7 @@
 }
 
 struct output_file *open_output_file(const char *filename,
-		unsigned int block_size, off64_t len,
+		unsigned int block_size, int64_t len,
 		int gz, int sparse, int chunks, int crc)
 {
 	int fd;
@@ -447,7 +449,7 @@
 	return file;
 }
 
-void pad_output_file(struct output_file *out, off64_t len)
+void pad_output_file(struct output_file *out, int64_t len)
 {
 	int ret;
 
@@ -484,7 +486,7 @@
 }
 
 /* Write a contiguous region of data blocks from a memory buffer */
-void write_data_block(struct output_file *out, off64_t off, void *data, int len)
+void write_data_block(struct output_file *out, int64_t off, void *data, int len)
 {
 	int ret;
 
@@ -508,7 +510,7 @@
 }
 
 /* Write a contiguous region of data blocks with a fill value */
-void write_fill_block(struct output_file *out, off64_t off, unsigned int fill_val, int len)
+void write_fill_block(struct output_file *out, int64_t off, unsigned int fill_val, int len)
 {
 	int ret;
 	unsigned int i;
@@ -546,11 +548,11 @@
 }
 
 /* Write a contiguous region of data blocks from a file */
-void write_data_file(struct output_file *out, off64_t off, const char *file,
-		     off64_t offset, int len)
+void write_data_file(struct output_file *out, int64_t off, const char *file,
+		int64_t offset, int len)
 {
 	int ret;
-	off64_t aligned_offset;
+	int64_t aligned_offset;
 	int aligned_diff;
 	int buffer_size;
 
diff --git a/ext4_utils/libsparse/output_file.h b/ext4_utils/libsparse/output_file.h
index 9e822e3..b12194f 100644
--- a/ext4_utils/libsparse/output_file.h
+++ b/ext4_utils/libsparse/output_file.h
@@ -22,15 +22,15 @@
 struct output_file;
 
 struct output_file *open_output_file(const char *filename,
-		unsigned int block_size, off64_t len,
+		unsigned int block_size, int64_t len,
 		int gz, int sparse, int chunks, int crc);
-struct output_file *open_output_fd(int fd, unsigned int block_size, off64_t len,
+struct output_file *open_output_fd(int fd, unsigned int block_size, int64_t len,
 		int gz, int sparse, int chunks, int crc);
-void write_data_block(struct output_file *out, off64_t off, void *data, int len);
-void write_fill_block(struct output_file *out, off64_t off, unsigned int fill_val, int len);
-void write_data_file(struct output_file *out, off64_t off, const char *file,
-		     off64_t offset, int len);
-void pad_output_file(struct output_file *out, off64_t len);
+void write_data_block(struct output_file *out, int64_t off, void *data, int len);
+void write_fill_block(struct output_file *out, int64_t off, unsigned int fill_val, int len);
+void write_data_file(struct output_file *out, int64_t off, const char *file,
+		int64_t offset, int len);
+void pad_output_file(struct output_file *out, int64_t len);
 void close_output_file(struct output_file *out);
 
 #endif
diff --git a/ext4_utils/libsparse/sparse.c b/ext4_utils/libsparse/sparse.c
index 2c91a8e..d6f5561 100644
--- a/ext4_utils/libsparse/sparse.c
+++ b/ext4_utils/libsparse/sparse.c
@@ -14,17 +14,70 @@
  * limitations under the License.
  */
 
+#include <stdlib.h>
+
+#include <sparse/sparse.h>
+
+#include "sparse_file.h"
+
 #include "output_file.h"
 #include "backed_block.h"
 #include "sparse_defs.h"
 
+
+struct sparse_file *sparse_file_new(unsigned int block_size, int64_t len)
+{
+	struct sparse_file *s = calloc(sizeof(struct sparse_file), 1);
+	if (!s) {
+		return NULL;
+	}
+
+	/* TODO: allocate backed block list */
+
+	s->block_size = block_size;
+	s->len = len;
+
+	return s;
+}
+
+void sparse_file_destroy(struct sparse_file *s)
+{
+	free_data_blocks();
+	free(s);
+}
+
+int sparse_file_add_data(struct sparse_file *s,
+		void *data, unsigned int len, unsigned int block)
+{
+	queue_data_block(data, len, block);
+
+	return 0;
+}
+
+int sparse_file_add_fill(struct sparse_file *s,
+		uint32_t fill_val, unsigned int len, unsigned int block)
+{
+	queue_fill_block(fill_val, len, block);
+
+	return 0;
+}
+
+int sparse_file_add_file(struct sparse_file *s,
+		const char *filename, int64_t file_offset, unsigned int len,
+		unsigned int block)
+{
+	queue_data_file(filename, file_offset, len, block);
+
+	return 0;
+}
+
 struct count_chunks {
 	unsigned int chunks;
-	off64_t cur_ptr;
+	int64_t cur_ptr;
 	unsigned int block_size;
 };
 
-static void count_data_block(void *priv, off64_t off, void *data, int len)
+static void count_data_block(void *priv, int64_t off, void *data, int len)
 {
 	struct count_chunks *count_chunks = priv;
 	if (off > count_chunks->cur_ptr)
@@ -33,7 +86,7 @@
 	count_chunks->chunks++;
 }
 
-static void count_fill_block(void *priv, off64_t off, unsigned int fill_val, int len)
+static void count_fill_block(void *priv, int64_t off, unsigned int fill_val, int len)
 {
 	struct count_chunks *count_chunks = priv;
 	if (off > count_chunks->cur_ptr)
@@ -42,8 +95,8 @@
 	count_chunks->chunks++;
 }
 
-static void count_file_block(void *priv, off64_t off, const char *file,
-		off64_t offset, int len)
+static void count_file_block(void *priv, int64_t off, const char *file,
+		int64_t offset, int len)
 {
 	struct count_chunks *count_chunks = priv;
 	if (off > count_chunks->cur_ptr)
@@ -52,7 +105,7 @@
 	count_chunks->chunks++;
 }
 
-static int count_sparse_chunks(unsigned int block_size, off64_t len)
+static int count_sparse_chunks(unsigned int block_size, int64_t len)
 {
 	struct count_chunks count_chunks = {0, 0, block_size};
 
@@ -64,35 +117,38 @@
 	return count_chunks.chunks;
 }
 
-static void ext4_write_data_block(void *priv, off64_t off, void *data, int len)
+static void ext4_write_data_block(void *priv, int64_t off, void *data, int len)
 {
 	write_data_block(priv, off, data, len);
 }
 
-static void ext4_write_fill_block(void *priv, off64_t off, unsigned int fill_val, int len)
+static void ext4_write_fill_block(void *priv, int64_t off, unsigned int fill_val, int len)
 {
 	write_fill_block(priv, off, fill_val, len);
 }
 
-static void ext4_write_data_file(void *priv, off64_t off, const char *file,
-		off64_t offset, int len)
+static void ext4_write_data_file(void *priv, int64_t off, const char *file,
+		int64_t offset, int len)
 {
 	write_data_file(priv, off, file, offset, len);
 }
 
-/* Write the filesystem image to a file */
-void write_sparse_image(int fd, int gz, int sparse, int crc, unsigned int block_size, off64_t len)
+int sparse_file_write(struct sparse_file *s, int fd, bool gz, bool sparse,
+		bool crc)
 {
-	int chunks = count_sparse_chunks(block_size, len);
-	struct output_file *out = open_output_fd(fd, block_size, len,
+	int chunks = count_sparse_chunks(s->block_size, s->len);
+	struct output_file *out = open_output_fd(fd, s->block_size, s->len,
 			gz, sparse, chunks, crc);
 
 	if (!out)
-		return;
+		return -ENOMEM;
 
-	for_each_data_block(ext4_write_data_block, ext4_write_data_file, ext4_write_fill_block, out, block_size);
+	for_each_data_block(ext4_write_data_block, ext4_write_data_file, ext4_write_fill_block, out, s->block_size);
 
-	pad_output_file(out, len);
+	if (s->len)
+		pad_output_file(out, s->len);
 
 	close_output_file(out);
+
+	return 0;
 }
diff --git a/ext4_utils/libsparse/sparse_file.h b/ext4_utils/libsparse/sparse_file.h
new file mode 100644
index 0000000..05a78d9
--- /dev/null
+++ b/ext4_utils/libsparse/sparse_file.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _LIBSPARSE_SPARSE_FILE_H_
+#define _LIBSPARSE_SPARSE_FILE_H_
+
+#include <sparse/sparse.h>
+
+struct sparse_file {
+	unsigned int block_size;
+	int64_t len;
+
+	struct output_file *out;
+};
+
+
+#endif /* _LIBSPARSE_SPARSE_FILE_H_ */
diff --git a/ext4_utils/make_ext4fs.c b/ext4_utils/make_ext4fs.c
index 228c421..be63e27 100644
--- a/ext4_utils/make_ext4fs.c
+++ b/ext4_utils/make_ext4fs.c
@@ -294,7 +294,11 @@
     // can be called again.
     memset(&info, 0, sizeof(info));
     memset(&aux_info, 0, sizeof(aux_info));
-    free_data_blocks();
+
+    if (info.sparse_file) {
+        sparse_file_destroy(info.sparse_file);
+        info.sparse_file = NULL;
+    }
 }
 
 int make_ext4fs(const char *filename, s64 len,
@@ -393,6 +397,8 @@
 	printf("    Block groups: %d\n", aux_info.groups);
 	printf("    Reserved block group size: %d\n", info.bg_desc_reserve_blocks);
 
+	info.sparse_file = sparse_file_new(info.block_size, info.len);
+
 	block_allocator_init();
 
 	ext4_fill_in_sb();
@@ -462,5 +468,8 @@
 
 	write_ext4_image(fd, gzip, sparse, crc);
 
+	sparse_file_destroy(info.sparse_file);
+	info.sparse_file = NULL;
+
 	return 0;
 }