diff: introduce binary diff callbacks

Introduce a new binary diff callback to provide the actual binary
delta contents to callers.  Create this data from the diff contents
(instead of directly from the ODB) to support binary diffs including
the workdir, not just things coming out of the ODB.

18 files changed, 691 insertions, 375 deletions

diff --git a/include/git2/diff.h b/include/git2/diff.h
index c0d42e30e..0ecdc1bed 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -426,6 +426,53 @@ typedef int (*git_diff_file_cb)(
 	void *payload);
 
 /**
+ * When producing a binary diff, the binary data returned will be
+ * either the deflated full ("literal") contents of the file, or
+ * the deflated binary delta between the two sides (whichever is
+ * smaller).
+ */
+typedef enum {
+	/** There is no binary delta. */
+	GIT_DIFF_BINARY_NONE,
+
+	/** The binary data is the literal contents of the file. */
+	GIT_DIFF_BINARY_LITERAL,
+
+	/** The binary data is the delta from one side to the other. */
+	GIT_DIFF_BINARY_DELTA,
+} git_diff_binary_t;
+
+/** The contents of one of the files in a binary diff. */
+typedef struct {
+	/** The type of binary data for this file. */
+	git_diff_binary_t type;
+
+	/** The binary data, deflated. */
+	const char *data;
+
+	/** The length of the binary data. */
+	size_t datalen;
+
+	/** The length of the binary data after inflation. */
+	size_t inflatedlen;
+} git_diff_binary_file;
+
+/** Structure describing the binary contents of a diff. */
+typedef struct {
+	git_diff_binary_file old_file; /**< The contents of the old file. */
+	git_diff_binary_file new_file; /**< The contents of the new file. */
+} git_diff_binary;
+
+/**
+* When iterating over a diff, callback that will be made for
+* binary content within the diff.
+*/
+typedef int(*git_diff_binary_cb)(
+	const git_diff_delta *delta,
+	const git_diff_binary *binary,
+	void *payload);
+
+/**
  * Structure describing a hunk of a diff.
  */
 typedef struct {
@@ -897,6 +944,7 @@ GIT_EXTERN(int) git_diff_is_sorted_icase(const git_diff *diff);
  *
  * @param diff A git_diff generated by one of the above functions.
  * @param file_cb Callback function to make per file in the diff.
+ * @param binary_cb Optional callback to make for binary files.
  * @param hunk_cb Optional callback to make per hunk of text diff.  This
  *                callback is called to describe a range of lines in the
  *                diff.  It will not be issued for binary files.
@@ -909,6 +957,7 @@ GIT_EXTERN(int) git_diff_is_sorted_icase(const git_diff *diff);
 GIT_EXTERN(int) git_diff_foreach(
 	git_diff *diff,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *payload);
@@ -984,6 +1033,7 @@ GIT_EXTERN(int) git_diff_print(
  * @param new_as_path Treat new blob as if it had this filename; can be NULL
  * @param options Options for diff, or NULL for default options
  * @param file_cb Callback for "file"; made once if there is a diff; can be NULL
+ * @param binary_cb Callback for binary files; can be NULL
  * @param hunk_cb Callback for each hunk in diff; can be NULL
  * @param line_cb Callback for each line in diff; can be NULL
  * @param payload Payload passed to each callback function
@@ -996,6 +1046,7 @@ GIT_EXTERN(int) git_diff_blobs(
 	const char *new_as_path,
 	const git_diff_options *options,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *payload);
@@ -1019,6 +1070,7 @@ GIT_EXTERN(int) git_diff_blobs(
  * @param buffer_as_path Treat buffer as if it had this filename; can be NULL
  * @param options Options for diff, or NULL for default options
  * @param file_cb Callback for "file"; made once if there is a diff; can be NULL
+ * @param binary_cb Callback for binary files; can be NULL
  * @param hunk_cb Callback for each hunk in diff; can be NULL
  * @param line_cb Callback for each line in diff; can be NULL
  * @param payload Payload passed to each callback function
@@ -1032,6 +1084,7 @@ GIT_EXTERN(int) git_diff_blob_to_buffer(
 	const char *buffer_as_path,
 	const git_diff_options *options,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *payload);
@@ -1051,6 +1104,7 @@ GIT_EXTERN(int) git_diff_blob_to_buffer(
  * @param new_as_path Treat buffer as if it had this filename; can be NULL
  * @param options Options for diff, or NULL for default options
  * @param file_cb Callback for "file"; made once if there is a diff; can be NULL
+ * @param binary_cb Callback for binary files; can be NULL
  * @param hunk_cb Callback for each hunk in diff; can be NULL
  * @param line_cb Callback for each line in diff; can be NULL
  * @param payload Payload passed to each callback function
@@ -1065,6 +1119,7 @@ GIT_EXTERN(int) git_diff_buffers(
 	const char *new_as_path,
 	const git_diff_options *options,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *payload);
diff --git a/src/blame.c b/src/blame.c
index 4a12cb85b..a52f9402b 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -496,8 +496,8 @@ int git_blame_buffer(
 
 	/* Diff to the reference blob */
 	git_diff_blob_to_buffer(reference->final_blob, blame->path,
-			buffer, buffer_len, blame->path,
-			&diffopts, NULL, buffer_hunk_cb, buffer_line_cb, blame);
+		buffer, buffer_len, blame->path, &diffopts,
+		NULL, NULL, buffer_hunk_cb, buffer_line_cb, blame);
 
 	*out = blame;
 	return 0;
diff --git a/src/diff_file.c b/src/diff_file.c
index f7061ae83..cef4bc169 100644
--- a/src/diff_file.c
+++ b/src/diff_file.c
@@ -89,10 +89,9 @@ static int diff_file_content_init_common(
 int git_diff_file_content__init_from_diff(
 	git_diff_file_content *fc,
 	git_diff *diff,
-	size_t delta_index,
+	git_diff_delta *delta,
 	bool use_old)
 {
-	git_diff_delta *delta = git_vector_get(&diff->deltas, delta_index);
 	bool has_data = true;
 
 	memset(fc, 0, sizeof(*fc));
@@ -218,7 +217,9 @@ static int diff_file_content_commit_to_str(
 	return 0;
 }
 
-static int diff_file_content_load_blob(git_diff_file_content *fc)
+static int diff_file_content_load_blob(
+	git_diff_file_content *fc,
+	git_diff_options *opts)
 {
 	int error = 0;
 	git_odb_object *odb_obj = NULL;
@@ -236,7 +237,8 @@ static int diff_file_content_load_blob(git_diff_file_content *fc)
 			return error;
 	}
 
-	if (diff_file_content_binary_by_size(fc))
+	if ((opts->flags & GIT_DIFF_SHOW_BINARY) == 0 &&
+		diff_file_content_binary_by_size(fc))
 		return 0;
 
 	if (odb_obj != NULL) {
@@ -283,7 +285,9 @@ static int diff_file_content_load_workdir_symlink(
 }
 
 static int diff_file_content_load_workdir_file(
-	git_diff_file_content *fc, git_buf *path)
+	git_diff_file_content *fc,
+	git_buf *path,
+	git_diff_options *diff_opts)
 {
 	int error = 0;
 	git_filter_list *fl = NULL;
@@ -297,7 +301,8 @@ static int diff_file_content_load_workdir_file(
 		!(fc->file->size = git_futils_filesize(fd)))
 		goto cleanup;
 
-	if (diff_file_content_binary_by_size(fc))
+	if ((diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0 &&
+		diff_file_content_binary_by_size(fc))
 		goto cleanup;
 
 	if ((error = git_filter_list_load(
@@ -339,7 +344,9 @@ cleanup:
 	return error;
 }
 
-static int diff_file_content_load_workdir(git_diff_file_content *fc)
+static int diff_file_content_load_workdir(
+	git_diff_file_content *fc,
+	git_diff_options *diff_opts)
 {
 	int error = 0;
 	git_buf path = GIT_BUF_INIT;
@@ -357,7 +364,7 @@ static int diff_file_content_load_workdir(git_diff_file_content *fc)
 	if (S_ISLNK(fc->file->mode))
 		error = diff_file_content_load_workdir_symlink(fc, &path);
 	else
-		error = diff_file_content_load_workdir_file(fc, &path);
+		error = diff_file_content_load_workdir_file(fc, &path, diff_opts);
 
 	/* once data is loaded, update OID if we didn't have it previously */
 	if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
@@ -370,20 +377,23 @@ static int diff_file_content_load_workdir(git_diff_file_content *fc)
 	return error;
 }
 
-int git_diff_file_content__load(git_diff_file_content *fc)
+int git_diff_file_content__load(
+	git_diff_file_content *fc,
+	git_diff_options *diff_opts)
 {
 	int error = 0;
 
 	if ((fc->flags & GIT_DIFF_FLAG__LOADED) != 0)
 		return 0;
 
-	if ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0)
+	if ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0 &&
+		(diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0)
 		return 0;
 
 	if (fc->src == GIT_ITERATOR_TYPE_WORKDIR)
-		error = diff_file_content_load_workdir(fc);
+		error = diff_file_content_load_workdir(fc, diff_opts);
 	else
-		error = diff_file_content_load_blob(fc);
+		error = diff_file_content_load_blob(fc, diff_opts);
 	if (error)
 		return error;
 
diff --git a/src/diff_file.h b/src/diff_file.h
index 4d290ad43..0d54b6d33 100644
--- a/src/diff_file.h
+++ b/src/diff_file.h
@@ -28,7 +28,7 @@ typedef struct {
 extern int git_diff_file_content__init_from_diff(
 	git_diff_file_content *fc,
 	git_diff *diff,
-	size_t delta_index,
+	git_diff_delta *delta,
 	bool use_old);
 
 typedef struct {
@@ -49,7 +49,9 @@ extern int git_diff_file_content__init_from_src(
 	git_diff_file *as_file);
 
 /* this loads the blob/file-on-disk as needed */
-extern int git_diff_file_content__load(git_diff_file_content *fc);
+extern int git_diff_file_content__load(
+	git_diff_file_content *fc,
+	git_diff_options *diff_opts);
 
 /* this releases the blob/file-in-memory */
 extern void git_diff_file_content__unload(git_diff_file_content *fc);
diff --git a/src/diff_patch.c b/src/diff_patch.c
index 1c4c0e8b8..81b93e93e 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -11,41 +11,13 @@
 #include "diff_driver.h"
 #include "diff_patch.h"
 #include "diff_xdiff.h"
+#include "delta.h"
+#include "zstream.h"
 #include "fileops.h"
 
-/* cached information about a hunk in a diff */
-typedef struct diff_patch_hunk {
-	git_diff_hunk hunk;
-	size_t line_start;
-	size_t line_count;
-} diff_patch_hunk;
-
-struct git_patch {
-	git_refcount rc;
-	git_diff *diff; /* for refcount purposes, maybe NULL for blob diffs */
-	git_diff_delta *delta;
-	size_t delta_index;
-	git_diff_file_content ofile;
-	git_diff_file_content nfile;
-	uint32_t flags;
-	git_array_t(diff_patch_hunk) hunks;
-	git_array_t(git_diff_line)   lines;
-	size_t content_size, context_size, header_size;
-	git_pool flattened;
-};
-
-enum {
-	GIT_DIFF_PATCH_ALLOCATED   = (1 << 0),
-	GIT_DIFF_PATCH_INITIALIZED = (1 << 1),
-	GIT_DIFF_PATCH_LOADED      = (1 << 2),
-	GIT_DIFF_PATCH_DIFFABLE    = (1 << 3),
-	GIT_DIFF_PATCH_DIFFED      = (1 << 4),
-	GIT_DIFF_PATCH_FLATTENED   = (1 << 5),
-};
-
 static void diff_output_init(
-	git_diff_output*, const git_diff_options*,
-	git_diff_file_cb, git_diff_hunk_cb, git_diff_line_cb, void*);
+	git_diff_output*, const git_diff_options*, git_diff_file_cb,
+	git_diff_binary_cb, git_diff_hunk_cb, git_diff_line_cb, void*);
 
 static void diff_output_to_patch(git_diff_output *, git_patch *);
 
@@ -67,15 +39,38 @@ static void diff_patch_init_common(git_patch *patch)
 {
 	diff_patch_update_binary(patch);
 
-	if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0)
-		patch->flags |= GIT_DIFF_PATCH_LOADED; /* LOADED but not DIFFABLE */
-
 	patch->flags |= GIT_DIFF_PATCH_INITIALIZED;
 
 	if (patch->diff)
 		git_diff_addref(patch->diff);
 }
 
+static int diff_patch_normalize_options(
+	git_diff_options *out,
+	const git_diff_options *opts)
+{
+	if (opts) {
+		GITERR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
+		memcpy(out, opts, sizeof(git_diff_options));
+	} else {
+		git_diff_options default_opts = GIT_DIFF_OPTIONS_INIT;
+		memcpy(out, &default_opts, sizeof(git_diff_options));
+	}
+
+	out->old_prefix = opts && opts->old_prefix ?
+		git__strdup(opts->old_prefix) :
+		git__strdup(DIFF_OLD_PREFIX_DEFAULT);
+
+	out->new_prefix = opts && opts->new_prefix ?
+		git__strdup(opts->new_prefix) :
+		git__strdup(DIFF_NEW_PREFIX_DEFAULT);
+
+	GITERR_CHECK_ALLOC(out->old_prefix);
+	GITERR_CHECK_ALLOC(out->new_prefix);
+
+	return 0;
+}
+
 static int diff_patch_init_from_diff(
 	git_patch *patch, git_diff *diff, size_t delta_index)
 {
@@ -86,10 +81,12 @@ static int diff_patch_init_from_diff(
 	patch->delta = git_vector_get(&diff->deltas, delta_index);
 	patch->delta_index = delta_index;
 
-	if ((error = git_diff_file_content__init_from_diff(
-			&patch->ofile, diff, delta_index, true)) < 0 ||
+	if ((error = diff_patch_normalize_options(
+			&patch->diff_opts, &diff->opts)) < 0 ||
 		(error = git_diff_file_content__init_from_diff(
-			&patch->nfile, diff, delta_index, false)) < 0)
+			&patch->ofile, diff, patch->delta, true)) < 0 ||
+		(error = git_diff_file_content__init_from_diff(
+			&patch->nfile, diff, patch->delta, false)) < 0)
 		return error;
 
 	diff_patch_init_common(patch);
@@ -116,6 +113,14 @@ static int diff_patch_alloc_from_diff(
 	return error;
 }
 
+GIT_INLINE(bool) should_skip_binary(git_patch *patch, git_diff_file *file)
+{
+	if ((patch->diff_opts.flags & GIT_DIFF_SHOW_BINARY) != 0)
+		return false;
+
+	return (file->flags & GIT_DIFF_FLAG_BINARY) != 0;
+}
+
 static int diff_patch_load(git_patch *patch, git_diff_output *output)
 {
 	int error = 0;
@@ -128,7 +133,7 @@ static int diff_patch_load(git_patch *patch, git_diff_output *output)
 	 * binary, then there is no need to actually load the data
 	 */
 	if ((patch->ofile.opts_flags & GIT_DIFF_SKIP_BINARY_CHECK) != 0 &&
-		output && !output->hunk_cb && !output->data_cb)
+		output && !output->binary_cb && !output->hunk_cb && !output->data_cb)
 		return 0;
 
 	incomplete_data =
@@ -141,25 +146,29 @@ static int diff_patch_load(git_patch *patch, git_diff_output *output)
 	 * need 2x data size and this minimizes peak memory footprint
 	 */
 	if (patch->ofile.src == GIT_ITERATOR_TYPE_WORKDIR) {
-		if ((error = git_diff_file_content__load(&patch->ofile)) < 0 ||
-			(patch->ofile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
+		if ((error = git_diff_file_content__load(
+				&patch->ofile, &patch->diff_opts)) < 0 ||
+			should_skip_binary(patch, patch->ofile.file))
 			goto cleanup;
 	}
 	if (patch->nfile.src == GIT_ITERATOR_TYPE_WORKDIR) {
-		if ((error = git_diff_file_content__load(&patch->nfile)) < 0 ||
-			(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
+		if ((error = git_diff_file_content__load(
+				&patch->nfile, &patch->diff_opts)) < 0 ||
+			should_skip_binary(patch, patch->nfile.file))
 			goto cleanup;
 	}
 
 	/* once workdir has been tried, load other data as needed */
 	if (patch->ofile.src != GIT_ITERATOR_TYPE_WORKDIR) {
-		if ((error = git_diff_file_content__load(&patch->ofile)) < 0 ||
-			(patch->ofile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
+		if ((error = git_diff_file_content__load(
+				&patch->ofile, &patch->diff_opts)) < 0 ||
+			should_skip_binary(patch, patch->ofile.file))
 			goto cleanup;
 	}
 	if (patch->nfile.src != GIT_ITERATOR_TYPE_WORKDIR) {
-		if ((error = git_diff_file_content__load(&patch->nfile)) < 0 ||
-			(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
+		if ((error = git_diff_file_content__load(
+				&patch->nfile, &patch->diff_opts)) < 0 ||
+			should_skip_binary(patch, patch->nfile.file))
 			goto cleanup;
 	}
 
@@ -177,10 +186,14 @@ cleanup:
 	diff_patch_update_binary(patch);
 
 	if (!error) {
+		bool skip_binary =
+			(patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0 &&
+			(patch->diff_opts.flags & GIT_DIFF_SHOW_BINARY) == 0;
+
 		/* patch is diffable only for non-binary, modified files where
-		 * at least one side has data and the data actually changed
-		 */
-		if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) == 0 &&
+		* at least one side has data and the data actually changed
+		*/
+		if (!skip_binary &&
 			patch->delta->status != GIT_DELTA_UNMODIFIED &&
 			(patch->ofile.map.len || patch->nfile.map.len) &&
 			(patch->ofile.map.len != patch->nfile.map.len ||
@@ -207,6 +220,98 @@ static int diff_patch_invoke_file_callback(
 		"git_patch");
 }
 
+static int create_binary(
+	git_diff_binary_t *out_type,
+	char **out_data,
+	size_t *out_datalen,
+	size_t *out_inflatedlen,
+	const char *a_data,
+	size_t a_datalen,
+	const char *b_data,
+	size_t b_datalen)
+{
+	git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT;
+	unsigned long delta_data_len;
+	int error;
+
+	/* The git_delta function accepts unsigned long only */
+	if (!git__is_ulong(a_datalen) || !git__is_ulong(b_datalen))
+		return GIT_EBUFS;
+
+	if ((error = git_zstream_deflatebuf(&deflate, b_data, b_datalen)) < 0)
+		goto done;
+
+	/* The git_delta function accepts unsigned long only */
+	if (!git__is_ulong(deflate.size)) {
+		error = GIT_EBUFS;
+		goto done;
+	}
+
+	if (a_datalen && b_datalen) {
+		void *delta_data = git_delta(
+			a_data, (unsigned long)a_datalen,
+			b_data, (unsigned long)b_datalen,
+			&delta_data_len, (unsigned long)deflate.size);
+
+		if (delta_data) {
+			error = git_zstream_deflatebuf(
+				&delta, delta_data, (size_t)delta_data_len);
+
+			git__free(delta_data);
+
+			if (error < 0)
+				goto done;
+		}
+	}
+
+	if (delta.size && delta.size < deflate.size) {
+		*out_type = GIT_DIFF_BINARY_DELTA;
+		*out_datalen = delta.size;
+		*out_data = git_buf_detach(&delta);
+		*out_inflatedlen = delta_data_len;
+	} else {
+		*out_type = GIT_DIFF_BINARY_LITERAL;
+		*out_datalen = deflate.size;
+		*out_data = git_buf_detach(&deflate);
+		*out_inflatedlen = b_datalen;
+	}
+
+done:
+	git_buf_free(&deflate);
+	git_buf_free(&delta);
+
+	return error;
+}
+
+static int diff_binary(git_diff_output *output, git_patch *patch)
+{
+	git_diff_binary binary = { 0 };
+	const char *old_data = patch->ofile.map.data;
+	const char *new_data = patch->nfile.map.data;
+	size_t old_len = patch->ofile.map.len,
+		new_len = patch->nfile.map.len;
+	int error;
+
+	/* Create the old->new delta (as the "new" side of the patch),
+	 * and the new->old delta (as the "old" side)
+	 */
+	if ((error = create_binary(&binary.old_file.type,
+			(char **)&binary.old_file.data,
+			&binary.old_file.datalen,
+			&binary.old_file.inflatedlen,
+			new_data, new_len, old_data, old_len)) < 0 ||
+		(error = create_binary(&binary.new_file.type,
+			(char **)&binary.new_file.data,
+			&binary.new_file.datalen,
+			&binary.new_file.inflatedlen,
+			old_data, old_len, new_data, new_len)) < 0)
+		return error;
+
+	return giterr_set_after_callback_function(
+		output->binary_cb(patch->delta, &binary, output->payload),
+		"git_patch");
+}
+
 static int diff_patch_generate(git_patch *patch, git_diff_output *output)
 {
 	int error = 0;
@@ -214,8 +319,8 @@ static int diff_patch_generate(git_patch *patch, git_diff_output *output)
 	if ((patch->flags & GIT_DIFF_PATCH_DIFFED) != 0)
 		return 0;
 
-	/* if we are not looking at the hunks and lines, don't do the diff */
-	if (!output->hunk_cb && !output->data_cb)
+	/* if we are not looking at the binary or text data, don't do the diff */
+	if (!output->binary_cb && !output->hunk_cb && !output->data_cb)
 		return 0;
 
 	if ((patch->flags & GIT_DIFF_PATCH_LOADED) == 0 &&
@@ -225,10 +330,16 @@ static int diff_patch_generate(git_patch *patch, git_diff_output *output)
 	if ((patch->flags & GIT_DIFF_PATCH_DIFFABLE) == 0)
 		return 0;
 
-	if (output->diff_cb != NULL &&
-		(error = output->diff_cb(output, patch)) < 0)
-		patch->flags |= GIT_DIFF_PATCH_DIFFED;
+	if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0) {
+		if (output->binary_cb)
+			error = diff_binary(output, patch);
+	}
+	else {
+		if (output->diff_cb)
+			error = output->diff_cb(output, patch);
+	}
 
+	patch->flags |= GIT_DIFF_PATCH_DIFFED;
 	return error;
 }
 
@@ -245,6 +356,9 @@ static void diff_patch_free(git_patch *patch)
 
 	git_pool_clear(&patch->flattened);
 
+	git__free((char *)patch->diff_opts.old_prefix);
+	git__free((char *)patch->diff_opts.new_prefix);
+
 	if (patch->flags & GIT_DIFF_PATCH_ALLOCATED)
 		git__free(patch);
 }
@@ -260,6 +374,7 @@ static int diff_required(git_diff *diff, const char *action)
 int git_diff_foreach(
 	git_diff *diff,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb data_cb,
 	void *payload)
@@ -275,7 +390,7 @@ int git_diff_foreach(
 	memset(&xo, 0, sizeof(xo));
 	memset(&patch, 0, sizeof(patch));
 	diff_output_init(
-		&xo.output, &diff->opts, file_cb, hunk_cb, data_cb, payload);
+		&xo.output, &diff->opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, &diff->opts);
 
 	git_vector_foreach(&diff->deltas, idx, patch.delta) {
@@ -284,11 +399,15 @@ int git_diff_foreach(
 		if (git_diff_delta__should_skip(&diff->opts, patch.delta))
 			continue;
 
+		if (binary_cb || hunk_cb || data_cb) {
+			if ((error = diff_patch_init_from_diff(&patch, diff, idx)) != 0 ||
+				(error = diff_patch_load(&patch, &xo.output)) != 0)
+				return error;
+		}
+
 		if ((error = diff_patch_invoke_file_callback(&patch, &xo.output)) == 0) {
-			if (hunk_cb || data_cb) {
-				if ((error = diff_patch_init_from_diff(&patch, diff, idx)) == 0)
+			if (binary_cb || hunk_cb || data_cb)
 					error = diff_patch_generate(&patch, &xo.output);
-			}
 		}
 
 		git_patch_free(&patch);
@@ -419,6 +538,7 @@ static int diff_from_sources(
 	git_diff_file_content_src *newsrc,
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb data_cb,
 	void *payload)
@@ -429,7 +549,7 @@ static int diff_from_sources(
 
 	memset(&xo, 0, sizeof(xo));
 	diff_output_init(
-		&xo.output, opts, file_cb, hunk_cb, data_cb, payload);
+		&xo.output, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, opts);
 
 	memset(&pd, 0, sizeof(pd));
@@ -477,6 +597,7 @@ int git_diff_blobs(
 	const char *new_path,
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb data_cb,
 	void *payload)
@@ -486,7 +607,7 @@ int git_diff_blobs(
 	git_diff_file_content_src nsrc =
 		GIT_DIFF_FILE_CONTENT_SRC__BLOB(new_blob, new_path);
 	return diff_from_sources(
-		&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
+		&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
 }
 
 int git_patch_from_blobs(
@@ -512,6 +633,7 @@ int git_diff_blob_to_buffer(
 	const char *buf_path,
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb data_cb,
 	void *payload)
@@ -521,7 +643,7 @@ int git_diff_blob_to_buffer(
 	git_diff_file_content_src nsrc =
 		GIT_DIFF_FILE_CONTENT_SRC__BUF(buf, buflen, buf_path);
 	return diff_from_sources(
-		&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
+		&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
 }
 
 int git_patch_from_blob_and_buffer(
@@ -549,6 +671,7 @@ int git_diff_buffers(
 	const char *new_path,
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb data_cb,
 	void *payload)
@@ -558,7 +681,7 @@ int git_diff_buffers(
 	git_diff_file_content_src nsrc =
 		GIT_DIFF_FILE_CONTENT_SRC__BUF(new_buf, new_len, new_path);
 	return diff_from_sources(
-		&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
+		&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
 }
 
 int git_patch_from_buffers(
@@ -812,6 +935,7 @@ void git_patch__new_data(
 int git_patch__invoke_callbacks(
 	git_patch *patch,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *payload)
@@ -822,6 +946,13 @@ int git_patch__invoke_callbacks(
 	if (file_cb)
 		error = file_cb(patch->delta, 0, payload);
 
+	if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0) {
+		if (binary_cb)
+			error = binary_cb(patch->delta, &patch->binary, payload);
+
+		return error;
+	}
+
 	if (!hunk_cb && !line_cb)
 		return error;
 
@@ -855,6 +986,36 @@ static int diff_patch_file_cb(
 	return 0;
 }
 
+static int diff_patch_binary_cb(
+	const git_diff_delta *delta,
+	const git_diff_binary *binary,
+	void *payload)
+{
+	git_patch *patch = payload;
+
+	GIT_UNUSED(delta);
+
+	memcpy(&patch->binary, binary, sizeof(git_diff_binary));
+
+	if (binary->old_file.data) {
+		patch->binary.old_file.data = git__malloc(binary->old_file.datalen);
+		GITERR_CHECK_ALLOC(patch->binary.old_file.data);
+
+		memcpy((char *)patch->binary.old_file.data,
+			binary->old_file.data, binary->old_file.datalen);
+	}
+
+	if (binary->new_file.data) {
+		patch->binary.new_file.data = git__malloc(binary->new_file.datalen);
+		GITERR_CHECK_ALLOC(patch->binary.new_file.data);
+
+		memcpy((char *)patch->binary.new_file.data,
+			binary->new_file.data, binary->new_file.datalen);
+	}
+
+	return 0;
+}
+
 static int diff_patch_hunk_cb(
 	const git_diff_delta *delta,
 	const git_diff_hunk *hunk_,
@@ -921,6 +1082,7 @@ static void diff_output_init(
 	git_diff_output *out,
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb data_cb,
 	void *payload)
@@ -930,6 +1092,7 @@ static void diff_output_init(
 	memset(out, 0, sizeof(*out));
 
 	out->file_cb = file_cb;
+	out->binary_cb = binary_cb;
 	out->hunk_cb = hunk_cb;
 	out->data_cb = data_cb;
 	out->payload = payload;
@@ -938,6 +1101,11 @@ static void diff_output_init(
 static void diff_output_to_patch(git_diff_output *out, git_patch *patch)
 {
 	diff_output_init(
-		out, NULL,
-		diff_patch_file_cb, diff_patch_hunk_cb, diff_patch_line_cb, patch);
+		out,
+		NULL,
+		diff_patch_file_cb,
+		diff_patch_binary_cb,
+		diff_patch_hunk_cb,
+		diff_patch_line_cb,
+		patch);
 }
diff --git a/src/diff_patch.h b/src/diff_patch.h
index df2ba4c31..f6ce57ddd 100644
--- a/src/diff_patch.h
+++ b/src/diff_patch.h
@@ -13,6 +13,38 @@
 #include "array.h"
 #include "git2/patch.h"
 
+ /* cached information about a hunk in a diff */
+typedef struct diff_patch_hunk {
+	git_diff_hunk hunk;
+	size_t line_start;
+	size_t line_count;
+} diff_patch_hunk;
+
+enum {
+	GIT_DIFF_PATCH_ALLOCATED = (1 << 0),
+	GIT_DIFF_PATCH_INITIALIZED = (1 << 1),
+	GIT_DIFF_PATCH_LOADED = (1 << 2),
+	GIT_DIFF_PATCH_DIFFABLE = (1 << 3),
+	GIT_DIFF_PATCH_DIFFED = (1 << 4),
+	GIT_DIFF_PATCH_FLATTENED = (1 << 5),
+};
+
+struct git_patch {
+	git_refcount rc;
+	git_diff *diff; /* for refcount purposes, maybe NULL for blob diffs */
+	git_diff_options diff_opts;
+	git_diff_delta *delta;
+	size_t delta_index;
+	git_diff_file_content ofile;
+	git_diff_file_content nfile;
+	uint32_t flags;
+	git_diff_binary binary;
+	git_array_t(diff_patch_hunk) hunks;
+	git_array_t(git_diff_line)   lines;
+	size_t content_size, context_size, header_size;
+	git_pool flattened;
+};
+
 extern git_diff *git_patch__diff(git_patch *);
 
 extern git_diff_driver *git_patch__driver(git_patch *);
@@ -23,6 +55,7 @@ extern void git_patch__new_data(char **, size_t *, git_patch *);
 extern int git_patch__invoke_callbacks(
 	git_patch *patch,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *payload);
@@ -31,6 +64,7 @@ typedef struct git_diff_output git_diff_output;
 struct git_diff_output {
 	/* these callbacks are issued with the diff data */
 	git_diff_file_cb file_cb;
+	git_diff_binary_cb binary_cb;
 	git_diff_hunk_cb hunk_cb;
 	git_diff_line_cb data_cb;
 	void *payload;
diff --git a/src/diff_print.c b/src/diff_print.c
index 43a90b3d8..ebae4ea75 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -22,50 +22,92 @@ typedef struct {
 	uint32_t flags;
 	int oid_strlen;
 	git_diff_line line;
+	unsigned int
+		content_loaded : 1,
+		content_allocated : 1;
+	git_diff_file_content *ofile;
+	git_diff_file_content *nfile;
 } diff_print_info;
 
-static int diff_print_info_init(
+static int diff_print_info_init__common(
 	diff_print_info *pi,
 	git_buf *out,
-	git_diff *diff,
+	git_repository *repo,
 	git_diff_format_t format,
 	git_diff_line_cb cb,
 	void *payload)
 {
-	pi->diff     = diff;
-	pi->format   = format;
+	pi->format = format;
 	pi->print_cb = cb;
-	pi->payload  = payload;
-	pi->buf      = out;
-
-	if (diff)
-		pi->flags = diff->opts.flags;
-	else
-		pi->flags = 0;
-
-	if (diff && diff->opts.id_abbrev != 0)
-		pi->oid_strlen = diff->opts.id_abbrev;
-	else if (!diff || !diff->repo)
-		pi->oid_strlen = GIT_ABBREV_DEFAULT;
-	else if (git_repository__cvar(
-		&pi->oid_strlen, diff->repo, GIT_CVAR_ABBREV) < 0)
-		return -1;
+	pi->payload = payload;
+	pi->buf = out;
+
+	if (!pi->oid_strlen) {
+		if (!repo)
+			pi->oid_strlen = GIT_ABBREV_DEFAULT;
+		else if (git_repository__cvar(&pi->oid_strlen, repo, GIT_CVAR_ABBREV) < 0)
+			return -1;
+	}
 
 	pi->oid_strlen += 1; /* for NUL byte */
 
-	if (pi->oid_strlen < 2)
-		pi->oid_strlen = 2;
-	else if (pi->oid_strlen > GIT_OID_HEXSZ + 1)
+	if (pi->oid_strlen > GIT_OID_HEXSZ + 1)
 		pi->oid_strlen = GIT_OID_HEXSZ + 1;
 
 	memset(&pi->line, 0, sizeof(pi->line));
 	pi->line.old_lineno = -1;
 	pi->line.new_lineno = -1;
-	pi->line.num_lines  = 1;
+	pi->line.num_lines = 1;
 
 	return 0;
 }
 
+static int diff_print_info_init_fromdiff(
+	diff_print_info *pi,
+	git_buf *out,
+	git_diff *diff,
+	git_diff_format_t format,
+	git_diff_line_cb cb,
+	void *payload)
+{
+	git_repository *repo = diff ? diff->repo : NULL;
+
+	memset(pi, 0, sizeof(diff_print_info));
+
+	pi->diff = diff;
+
+	if (diff) {
+		pi->flags = diff->opts.flags;
+		pi->oid_strlen = diff->opts.id_abbrev;
+	}
+
+	return diff_print_info_init__common(pi, out, repo, format, cb, payload);
+}
+
+static int diff_print_info_init_frompatch(
+	diff_print_info *pi,
+	git_buf *out,
+	git_patch *patch,
+	git_diff_format_t format,
+	git_diff_line_cb cb,
+	void *payload)
+{
+	git_repository *repo = patch && patch->diff ? patch->diff->repo : NULL;
+
+	memset(pi, 0, sizeof(diff_print_info));
+
+	pi->diff = patch->diff;
+
+	pi->flags = patch->diff_opts.flags;
+	pi->oid_strlen = patch->diff_opts.id_abbrev;
+
+	pi->content_loaded = 1;
+	pi->ofile = &patch->ofile;
+	pi->nfile = &patch->nfile;
+
+	return diff_print_info_init__common(pi, out, repo, format, cb, payload);
+}
+
 static char diff_pick_suffix(int mode)
 {
 	if (S_ISDIR(mode))
@@ -283,66 +325,22 @@ int git_diff_delta__format_file_header(
 	return git_buf_oom(out) ? -1 : 0;
 }
 
-static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
+static int format_binary(
+	diff_print_info *pi,
+	git_diff_binary_t type,
+	const char *data,
+	size_t datalen,
+	size_t inflatedlen)
 {
-	git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT, *out = NULL;
-	const void *old_data, *new_data;
-	git_off_t old_data_len, new_data_len;
-	unsigned long delta_data_len, inflated_len;
-	const char *out_type = "literal";
-	char *scan, *end;
-	int error;
-
-	old_data = old ? git_blob_rawcontent(old) : NULL;
-	new_data = new ? git_blob_rawcontent(new) : NULL;
-
-	old_data_len = old ? git_blob_rawsize(old) : 0;
-	new_data_len = new ? git_blob_rawsize(new) : 0;
-
-	/* The git_delta function accepts unsigned long only */
-	if (!git__is_ulong(old_data_len) || !git__is_ulong(new_data_len))
-		return GIT_EBUFS;
-
-	out = &deflate;
-	inflated_len = (unsigned long)new_data_len;
-
-	if ((error = git_zstream_deflatebuf(
-			out, new_data, (size_t)new_data_len)) < 0)
-		goto done;
-
-	/* The git_delta function accepts unsigned long only */
-	if (!git__is_ulong((git_off_t)deflate.size)) {
-		error = GIT_EBUFS;
-		goto done;
-	}
+	const char *typename = type == GIT_DIFF_BINARY_DELTA ?
+		"delta" : "literal";
+	const char *scan, *end;
+	int error = 0;
 
-	if (old && new) {
-		void *delta_data = git_delta(
-			old_data, (unsigned long)old_data_len,
-			new_data, (unsigned long)new_data_len,
-			&delta_data_len, (unsigned long)deflate.size);
-
-		if (delta_data) {
-			error = git_zstream_deflatebuf(
-				&delta, delta_data, (size_t)delta_data_len);
-
-			git__free(delta_data);
-
-			if (error < 0)
-				goto done;
-
-			if (delta.size < deflate.size) {
-				out = &delta;
-				out_type = "delta";
-				inflated_len = delta_data_len;
-			}
-		}
-	}
-
-	git_buf_printf(pi->buf, "%s %lu\n", out_type, inflated_len);
+	git_buf_printf(pi->buf, "%s %lu\n", typename, inflatedlen);
 	pi->line.num_lines++;
 
-	for (scan = out->ptr, end = out->ptr + out->size; scan < end; ) {
+	for (scan = data, end = data + datalen; scan < end; ) {
 		size_t chunk_len = end - scan;
 		if (chunk_len > 52)
 			chunk_len = 52;
@@ -355,51 +353,74 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 		git_buf_encode_base85(pi->buf, scan, chunk_len);
 		git_buf_putc(pi->buf, '\n');
 
-		if (git_buf_oom(pi->buf)) {
-			error = -1;
-			goto done;
-		}
+		if (git_buf_oom(pi->buf))
+			return -1;
 
 		scan += chunk_len;
 		pi->line.num_lines++;
 	}
 
-done:
-	git_buf_free(&deflate);
-	git_buf_free(&delta);
+	return 0;
+}
 
-	return error;
+static int diff_print_load_content(
+	diff_print_info *pi,
+	git_diff_delta *delta)
+{
+	git_diff_file_content *ofile, *nfile;
+	int error;
+
+	assert(pi->diff);
+
+	ofile = git__calloc(1, sizeof(git_diff_file_content));
+	nfile = git__calloc(1, sizeof(git_diff_file_content));
+
+	GITERR_CHECK_ALLOC(ofile);
+	GITERR_CHECK_ALLOC(nfile);
+
+	if ((error = git_diff_file_content__init_from_diff(
+			ofile, pi->diff, delta, true)) < 0 ||
+		(error = git_diff_file_content__init_from_diff(
+			nfile, pi->diff, delta, true)) < 0) {
+
+		git__free(ofile);
+		git__free(nfile);
+		return error;
+	}
+
+	pi->content_loaded = 1;
+	pi->content_allocated = 1;
+	pi->ofile = ofile;
+	pi->nfile = nfile;
+
+	return 0;
 }
 
-/* git diff --binary 8d7523f~2 8d7523f~1 */
 static int diff_print_patch_file_binary(
-	diff_print_info *pi, const git_diff_delta *delta,
-	const char *oldpfx, const char *newpfx)
+	diff_print_info *pi, git_diff_delta *delta,
+	const char *old_pfx, const char *new_pfx,
+	const git_diff_binary *binary)
 {
-	git_blob *old = NULL, *new = NULL;
-	const git_oid *old_id, *new_id;
-	int error;
 	size_t pre_binary_size;
+	int error;
 
 	if ((pi->flags & GIT_DIFF_SHOW_BINARY) == 0)
 		goto noshow;
 
+	if (!pi->content_loaded &&
+		(error = diff_print_load_content(pi, delta)) < 0)
+		return error;
+
 	pre_binary_size = pi->buf->size;
 	git_buf_printf(pi->buf, "GIT binary patch\n");
 	pi->line.num_lines++;
 
-	old_id = (delta->status != GIT_DELTA_ADDED) ? &delta->old_file.id : NULL;
-	new_id = (delta->status != GIT_DELTA_DELETED) ? &delta->new_file.id : NULL;
-
-	if (old_id && (error = git_blob_lookup(&old, pi->diff->repo, old_id)) < 0)
-		goto done;
-	if (new_id && (error = git_blob_lookup(&new, pi->diff->repo,new_id)) < 0)
-		goto done;
-
-	if ((error = print_binary_hunk(pi, old, new)) < 0 ||
+	if ((error = format_binary(pi, binary->new_file.type, binary->new_file.data,
+		binary->new_file.datalen, binary->new_file.inflatedlen)) < 0 ||
 		(error = git_buf_putc(pi->buf, '\n')) < 0 ||
-		(error = print_binary_hunk(pi, new, old)) < 0)
-	{
+		(error = format_binary(pi, binary->old_file.type, binary->old_file.data,
+			binary->old_file.datalen, binary->old_file.inflatedlen)) < 0) {
+
 		if (error == GIT_EBUFS) {
 			giterr_clear();
 			git_buf_truncate(pi->buf, pre_binary_size);
@@ -408,17 +429,12 @@ static int diff_print_patch_file_binary(
 	}
 
 	pi->line.num_lines++;
-
-done:
-	git_blob_free(old);
-	git_blob_free(new);
-
 	return error;
 
 noshow:
 	pi->line.num_lines = 1;
 	return diff_delta_format_with_paths(
-		pi->buf, delta, oldpfx, newpfx,
+		pi->buf, delta, old_pfx, new_pfx,
 		"Binary files %s%s and %s%s differ\n");
 }
 
@@ -432,7 +448,8 @@ static int diff_print_patch_file(
 	const char *newpfx =
 		pi->diff ? pi->diff->opts.new_prefix : DIFF_NEW_PREFIX_DEFAULT;
 
-	bool binary = !!(delta->flags & GIT_DIFF_FLAG_BINARY);
+	bool binary = (delta->flags & GIT_DIFF_FLAG_BINARY) ||
+		(pi->flags & GIT_DIFF_FORCE_BINARY);
 	bool show_binary = !!(pi->flags & GIT_DIFF_SHOW_BINARY);
 	int oid_strlen = binary && show_binary ?
 		GIT_OID_HEXSZ + 1 : pi->oid_strlen;
@@ -455,19 +472,29 @@ static int diff_print_patch_file(
 	pi->line.content     = git_buf_cstr(pi->buf);
 	pi->line.content_len = git_buf_len(pi->buf);
 
-	if ((error = pi->print_cb(delta, NULL, &pi->line, pi->payload)) != 0)
-		return error;
+	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
+}
 
-	if (!binary)
-		return 0;
+static int diff_print_patch_binary(
+	const git_diff_delta *delta,
+	const git_diff_binary *binary,
+	void *data)
+{
+	diff_print_info *pi = data;
+	const char *old_pfx =
+		pi->diff ? pi->diff->opts.old_prefix : DIFF_OLD_PREFIX_DEFAULT;
+	const char *new_pfx =
+		pi->diff ? pi->diff->opts.new_prefix : DIFF_NEW_PREFIX_DEFAULT;
+	int error;
 
 	git_buf_clear(pi->buf);
 
-	if ((error = diff_print_patch_file_binary(pi, delta, oldpfx, newpfx)) < 0)
+	if ((error = diff_print_patch_file_binary(
+		pi, (git_diff_delta *)delta, old_pfx, new_pfx, binary)) < 0)
 		return error;
 
-	pi->line.origin      = GIT_DIFF_LINE_BINARY;
-	pi->line.content     = git_buf_cstr(pi->buf);
+	pi->line.origin = GIT_DIFF_LINE_BINARY;
+	pi->line.content = git_buf_cstr(pi->buf);
 	pi->line.content_len = git_buf_len(pi->buf);
 
 	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
@@ -515,12 +542,14 @@ int git_diff_print(
 	git_buf buf = GIT_BUF_INIT;
 	diff_print_info pi;
 	git_diff_file_cb print_file = NULL;
+	git_diff_binary_cb print_binary = NULL;
 	git_diff_hunk_cb print_hunk = NULL;
 	git_diff_line_cb print_line = NULL;
 
 	switch (format) {
 	case GIT_DIFF_FORMAT_PATCH:
 		print_file = diff_print_patch_file;
+		print_binary = diff_print_patch_binary;
 		print_hunk = diff_print_patch_hunk;
 		print_line = diff_print_patch_line;
 		break;
@@ -541,11 +570,10 @@ int git_diff_print(
 		return -1;
 	}
 
-	if (!(error = diff_print_info_init(
-			&pi, &buf, diff, format, print_cb, payload)))
-	{
+	if (!(error = diff_print_info_init_fromdiff(
+			&pi, &buf, diff, format, print_cb, payload))) {
 		error = git_diff_foreach(
-			diff, print_file, print_hunk, print_line, &pi);
+			diff, print_file, print_binary, print_hunk, print_line, &pi);
 
 		if (error) /* make sure error message is set */
 			giterr_set_after_callback_function(error, "git_diff_print");
@@ -568,13 +596,13 @@ int git_patch_print(
 
 	assert(patch && print_cb);
 
-	if (!(error = diff_print_info_init(
-			&pi, &temp, git_patch__diff(patch),
+	if (!(error = diff_print_info_init_frompatch(
+			&pi, &temp, patch,
 			GIT_DIFF_FORMAT_PATCH, print_cb, payload)))
 	{
 		error = git_patch__invoke_callbacks(
-			patch, diff_print_patch_file, diff_print_patch_hunk,
-			diff_print_patch_line, &pi);
+			patch, diff_print_patch_file, diff_print_patch_binary,
+			diff_print_patch_hunk, diff_print_patch_line, &pi);
 
 		if (error) /* make sure error message is set */
 			giterr_set_after_callback_function(error, "git_patch_print");
diff --git a/src/index.c b/src/index.c
index 0422ff1d4..14d8d3684 100644
--- a/src/index.c
+++ b/src/index.c
@@ -2727,7 +2727,7 @@ static int index_apply_to_wd_diff(git_index *index, int action, const git_strarr
 		goto cleanup;
 
 	data.pathspec = &ps;
-	error = git_diff_foreach(diff, apply_each_file, NULL, NULL, &data);
+	error = git_diff_foreach(diff, apply_each_file, NULL, NULL, NULL, &data);
 	git_diff_free(diff);
 
 	if (error) /* make sure error is set if callback stopped iteration */
diff --git a/tests/diff/blob.c b/tests/diff/blob.c
index 51bdbab15..b0253f6dc 100644
--- a/tests/diff/blob.c
+++ b/tests/diff/blob.c
@@ -17,7 +17,7 @@ static void quick_diff_blob_to_str(
 
 	cl_git_pass(git_diff_blob_to_buffer(
 		blob, blob_path, str, len, str_path,
-		&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		&opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 }
 
 void test_diff_blob__initialize(void)
@@ -88,7 +88,7 @@ void test_diff_blob__can_compare_text_blobs(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		a, NULL, b, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(1, 6, 1, 5, 0, &expected);
 
 	/* same diff but use direct buffers */
@@ -96,27 +96,27 @@ void test_diff_blob__can_compare_text_blobs(void)
 	cl_git_pass(git_diff_buffers(
 		git_blob_rawcontent(a), (size_t)git_blob_rawsize(a), NULL,
 		git_blob_rawcontent(b), (size_t)git_blob_rawsize(b), NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(1, 6, 1, 5, 0, &expected);
 
 	/* diff on tests/resources/attr/root_test2 */
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		b, NULL, c, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(1, 15, 3, 9, 3, &expected);
 
 	/* diff on tests/resources/attr/root_test3 */
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		a, NULL, c, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(1, 13, 0, 12, 1, &expected);
 
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		c, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(2, 14, 4, 6, 4, &expected);
 
 	git_blob_free(a);
@@ -206,7 +206,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		d, NULL, e, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.files);
 	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_DELETED]);
@@ -222,7 +222,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		d, NULL, e, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.files);
 	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_ADDED]);
@@ -238,7 +238,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		alien, NULL, NULL, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.files);
 	cl_assert_equal_i(1, expected.files_binary);
@@ -250,7 +250,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		NULL, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.files);
 	cl_assert_equal_i(1, expected.files_binary);
@@ -358,7 +358,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		d, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_identical_blobs_comparison(&expected);
 	cl_assert_equal_i(0, expected.files_binary);
@@ -366,7 +366,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		NULL, NULL, NULL, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_identical_blobs_comparison(&expected);
 	cl_assert_equal_i(0, expected.files_binary);
@@ -374,7 +374,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		alien, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_identical_blobs_comparison(&expected);
 	cl_assert(expected.files_binary > 0);
@@ -441,7 +441,7 @@ void test_diff_blob__can_compare_two_binary_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		alien, NULL, heart, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_binary_blobs_comparison(&expected);
 
@@ -449,7 +449,7 @@ void test_diff_blob__can_compare_two_binary_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		heart, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_binary_blobs_comparison(&expected);
 
@@ -460,7 +460,7 @@ void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
 {
 	cl_git_pass(git_diff_blobs(
 		alien, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_binary_blobs_comparison(&expected);
 
@@ -468,7 +468,7 @@ void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
 
 	cl_git_pass(git_diff_blobs(
 		d, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_binary_blobs_comparison(&expected);
 }
@@ -510,7 +510,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	/* Test with default inter-hunk-context (not set) => default is 0 */
 	cl_git_pass(git_diff_blobs(
 		old_d, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(2, expected.hunks);
 
@@ -519,7 +519,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		old_d, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(2, expected.hunks);
 
@@ -528,7 +528,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		old_d, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.hunks);
 
@@ -542,7 +542,7 @@ void test_diff_blob__checks_options_version_too_low(void)
 	opts.version = 0;
 	cl_git_fail(git_diff_blobs(
 		d, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	err = giterr_last();
 	cl_assert_equal_i(GITERR_INVALID, err->klass);
 }
@@ -554,7 +554,7 @@ void test_diff_blob__checks_options_version_too_high(void)
 	opts.version = 1024;
 	cl_git_fail(git_diff_blobs(
 		d, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	err = giterr_last();
 	cl_assert_equal_i(GITERR_INVALID, err->klass);
 }
@@ -752,7 +752,7 @@ void test_diff_blob__binary_data_comparisons(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		bin, NULL, nonbin, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_binary_blobs_comparison(&expected);
 
 	/*
@@ -773,7 +773,7 @@ void test_diff_blob__binary_data_comparisons(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		bin, NULL, nonbin, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified_with_lines(&expected, 4);
 
 	/* cleanup */
@@ -993,8 +993,8 @@ void test_diff_blob__can_compare_buffer_to_buffer(void)
 	memset(&expected, 0, sizeof(expected));
 
 	cl_git_pass(git_diff_buffers(
-		a, strlen(a), NULL, b, strlen(b), NULL,
-		&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		a, strlen(a), NULL, b, strlen(b), NULL, &opts,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(4, 9, 0, 4, 5, &expected);
 
 	opts.flags ^= GIT_DIFF_REVERSE;
@@ -1002,7 +1002,7 @@ void test_diff_blob__can_compare_buffer_to_buffer(void)
 	memset(&expected, 0, sizeof(expected));
 
 	cl_git_pass(git_diff_buffers(
-		a, strlen(a), NULL, b, strlen(b), NULL,
-		&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		a, strlen(a), NULL, b, strlen(b), NULL, &opts,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(4, 9, 0, 5, 4, &expected);
 }
diff --git a/tests/diff/diff_helpers.c b/tests/diff/diff_helpers.c
index 03862d6b4..c7352571c 100644
--- a/tests/diff/diff_helpers.c
+++ b/tests/diff/diff_helpers.c
@@ -91,6 +91,18 @@ int diff_print_file_cb(
 	return diff_file_cb(delta, progress, payload);
 }
 
+int diff_binary_cb(
+	const git_diff_delta *delta,
+	const git_diff_binary *binary,
+	void *payload)
+{
+	GIT_UNUSED(delta);
+	GIT_UNUSED(binary);
+	GIT_UNUSED(payload);
+
+	return 0;
+}
+
 int diff_hunk_cb(
 	const git_diff_delta *delta,
 	const git_diff_hunk *hunk,
@@ -145,6 +157,7 @@ int diff_line_cb(
 int diff_foreach_via_iterator(
 	git_diff *diff,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *data)
diff --git a/tests/diff/diff_helpers.h b/tests/diff/diff_helpers.h
index 6bcd1e671..4d3cd3474 100644
--- a/tests/diff/diff_helpers.h
+++ b/tests/diff/diff_helpers.h
@@ -42,6 +42,11 @@ extern int diff_print_file_cb(
 	float progress,
 	void *cb_data);
 
+extern int diff_binary_cb(
+	const git_diff_delta *delta,
+	const git_diff_binary *binary,
+	void *cb_data);
+
 extern int diff_hunk_cb(
 	const git_diff_delta *delta,
 	const git_diff_hunk *hunk,
@@ -56,6 +61,7 @@ extern int diff_line_cb(
 extern int diff_foreach_via_iterator(
 	git_diff *diff,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *data);
diff --git a/tests/diff/index.c b/tests/diff/index.c
index cf883f12a..242fb0046 100644
--- a/tests/diff/index.c
+++ b/tests/diff/index.c
@@ -35,7 +35,7 @@ void test_diff_index__0(void)
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	/* to generate these values:
 	 * - cd to tests/resources/status,
@@ -63,7 +63,7 @@ void test_diff_index__0(void)
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	/* to generate these values:
 	 * - cd to tests/resources/status,
@@ -127,8 +127,8 @@ void test_diff_index__1(void)
 
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
 
-	cl_assert_equal_i(
-		1, git_diff_foreach(diff, diff_stop_after_2_files, NULL, NULL, &exp) );
+	cl_assert_equal_i(1, git_diff_foreach(
+		diff, diff_stop_after_2_files, NULL, NULL, NULL, &exp) );
 
 	cl_assert_equal_i(2, exp.files);
 
@@ -193,7 +193,7 @@ static void do_conflicted_diff(diff_expects *exp, unsigned long flags)
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, index, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, exp));
 
 	git_diff_free(diff);
 	git_tree_free(a);
diff --git a/tests/diff/notify.c b/tests/diff/notify.c
index da7390d3f..6ef4af573 100644
--- a/tests/diff/notify.c
+++ b/tests/diff/notify.c
@@ -59,7 +59,7 @@ static void test_notify(
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(expected_diffed_files_count, exp.files);
 
@@ -222,7 +222,7 @@ void test_diff_notify__notify_cb_can_be_used_as_filtering_function(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index 8a327f035..5cfd8e235 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -65,7 +65,7 @@ void test_diff_rename__match_oid(void)
 	 */
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -81,7 +81,7 @@ void test_diff_rename__match_oid(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -102,7 +102,7 @@ void test_diff_rename__match_oid(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -124,7 +124,7 @@ void test_diff_rename__match_oid(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -204,7 +204,7 @@ void test_diff_rename__not_exact_match(void)
 	 */
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -222,7 +222,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -243,7 +243,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -266,7 +266,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -297,7 +297,7 @@ void test_diff_rename__not_exact_match(void)
 	 */
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -317,7 +317,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -344,7 +344,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -369,7 +369,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -469,7 +469,7 @@ void test_diff_rename__working_directory_changes(void)
 	/* git diff --no-renames 2bc7f351d20b53f1c72c16c4b036e491c478c49a */
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -482,7 +482,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
@@ -508,7 +508,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
@@ -527,7 +527,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
@@ -545,7 +545,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -575,7 +575,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -673,7 +673,7 @@ void test_diff_rename__file_exchange(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
 
@@ -682,7 +682,7 @@ void test_diff_rename__file_exchange(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -725,7 +725,7 @@ void test_diff_rename__file_exchange_three(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]);
 
@@ -734,7 +734,7 @@ void test_diff_rename__file_exchange_three(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -776,7 +776,7 @@ void test_diff_rename__file_partial_exchange(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
 
@@ -785,7 +785,7 @@ void test_diff_rename__file_partial_exchange(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
@@ -833,7 +833,7 @@ void test_diff_rename__rename_and_copy_from_same_source(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -843,7 +843,7 @@ void test_diff_rename__rename_and_copy_from_same_source(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_COPIED]);
 	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -885,7 +885,7 @@ void test_diff_rename__from_deleted_to_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -896,7 +896,7 @@ void test_diff_rename__from_deleted_to_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
@@ -998,8 +998,8 @@ void test_diff_rename__rejected_match_can_match_others(void)
 
 	cl_git_pass(git_diff_find_similar(diff, &findopts));
 
-	cl_git_pass(
-		git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
+	cl_git_pass(git_diff_foreach(
+		diff, test_names_expected, NULL, NULL, NULL, &expect));
 
 	git_diff_free(diff);
 	git_tree_free(tree);
@@ -1072,8 +1072,8 @@ void test_diff_rename__rejected_match_can_match_others_two(void)
 
 	cl_git_pass(git_diff_find_similar(diff, &findopts));
 
-	cl_git_pass(
-		git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
+	cl_git_pass(git_diff_foreach(
+		diff, test_names_expected, NULL, NULL, NULL, &expect));
 	cl_assert(expect.idx > 0);
 
 	git_diff_free(diff);
@@ -1128,8 +1128,8 @@ void test_diff_rename__rejected_match_can_match_others_three(void)
 
 	cl_git_pass(git_diff_find_similar(diff, &findopts));
 
-	cl_git_pass(
-		git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
+	cl_git_pass(git_diff_foreach(
+		diff, test_names_expected, NULL, NULL, NULL, &expect));
 
 	cl_assert(expect.idx == expect.len);
 
@@ -1177,8 +1177,8 @@ void test_diff_rename__can_rename_from_rewrite(void)
 
 	cl_git_pass(git_diff_find_similar(diff, &findopts));
 
-	cl_git_pass(
-		git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
+	cl_git_pass(git_diff_foreach(
+		diff, test_names_expected, NULL, NULL, NULL, &expect));
 
 	cl_assert(expect.idx == expect.len);
 
@@ -1210,7 +1210,7 @@ void test_diff_rename__case_changes_are_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
@@ -1220,7 +1220,7 @@ void test_diff_rename__case_changes_are_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -1252,7 +1252,7 @@ void test_diff_rename__unmodified_can_be_renamed(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
@@ -1262,13 +1262,13 @@ void test_diff_rename__unmodified_can_be_renamed(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -1317,7 +1317,7 @@ void test_diff_rename__rewrite_on_single_file(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
@@ -1352,7 +1352,7 @@ void test_diff_rename__can_find_copy_to_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -1362,7 +1362,7 @@ void test_diff_rename__can_find_copy_to_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
@@ -1401,7 +1401,7 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -1411,7 +1411,7 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
@@ -1451,7 +1451,7 @@ void test_diff_rename__matches_config_behavior(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
@@ -1465,7 +1465,7 @@ void test_diff_rename__matches_config_behavior(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
@@ -1479,7 +1479,7 @@ void test_diff_rename__matches_config_behavior(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1492,7 +1492,7 @@ void test_diff_rename__matches_config_behavior(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, NULL));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1535,7 +1535,7 @@ void test_diff_rename__can_override_thresholds_when_obeying_config(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1549,7 +1549,7 @@ void test_diff_rename__can_override_thresholds_when_obeying_config(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1590,7 +1590,7 @@ void test_diff_rename__by_config_doesnt_mess_with_whitespace_settings(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
@@ -1631,7 +1631,7 @@ static void expect_files_renamed(const char *one, const char *two, uint32_t whit
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -1686,7 +1686,7 @@ static void expect_files_not_renamed(const char *one, const char *two, uint32_t
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
diff --git a/tests/diff/submodules.c b/tests/diff/submodules.c
index 02870ac86..e2169583b 100644
--- a/tests/diff/submodules.c
+++ b/tests/diff/submodules.c
@@ -465,7 +465,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(0, exp.files);
 	git_diff_free(diff);
 
@@ -478,7 +478,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
 	git_diff_free(diff);
@@ -488,7 +488,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
 	git_diff_free(diff);
diff --git a/tests/diff/tree.c b/tests/diff/tree.c
index 6ab49fdb0..6dd17203d 100644
--- a/tests/diff/tree.c
+++ b/tests/diff/tree.c
@@ -49,7 +49,7 @@ void test_diff_tree__0(void)
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(5, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
@@ -71,7 +71,7 @@ void test_diff_tree__0(void)
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, b, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(2, expect.files);
 	cl_assert_equal_i(0, expect.file_status[GIT_DELTA_ADDED]);
@@ -158,7 +158,7 @@ void test_diff_tree__options(void)
 			cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, d, &opts));
 
 		cl_git_pass(git_diff_foreach(
-			diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &actual));
+			diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &actual));
 
 		expected = &test_expects[i];
 		cl_assert_equal_i(actual.files,     expected->files);
@@ -194,7 +194,7 @@ void test_diff_tree__bare(void)
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(3, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
@@ -235,7 +235,7 @@ void test_diff_tree__merge(void)
 	git_diff_free(diff2);
 
 	cl_git_pass(git_diff_foreach(
-		diff1, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+		diff1, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(6, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
@@ -332,7 +332,7 @@ void process_tree_to_tree_diffing(
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, NULL, NULL, &expect));
+		diff, diff_file_cb, NULL, NULL, NULL, &expect));
 }
 
 void test_diff_tree__symlink_blob_mode_changed_to_regular_file(void)
@@ -441,8 +441,8 @@ void test_diff_tree__issue_1397(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
 
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+	cl_git_pass(git_diff_foreach(diff,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(1, expect.files);
 	cl_assert_equal_i(0, expect.file_status[GIT_DELTA_DELETED]);
@@ -472,8 +472,8 @@ void test_diff_tree__diff_configs(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
 
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+	cl_git_pass(git_diff_foreach(diff, 
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(2, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
@@ -492,8 +492,8 @@ void test_diff_tree__diff_configs(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
 
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+	cl_git_pass(git_diff_foreach(diff,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(2, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
@@ -513,8 +513,8 @@ void test_diff_tree__diff_configs(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
 
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+	cl_git_pass(git_diff_foreach(diff,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(2, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 65005f927..5d6ebed95 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -30,10 +30,10 @@ void test_diff_workdir__to_index(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		/* to generate these values:
 		 * - cd to tests/resources/status,
@@ -94,7 +94,7 @@ void test_diff_workdir__to_index_with_conflicts(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, &opts));
 
 	cl_git_pass(diff_foreach_via_iterator(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(9, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -129,7 +129,7 @@ void test_diff_workdir__to_index_with_assume_unchanged(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(8, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);
@@ -158,7 +158,7 @@ void test_diff_workdir__to_index_with_assume_unchanged(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_DELETED]);
@@ -205,10 +205,10 @@ void test_diff_workdir__to_tree(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(14, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -241,10 +241,10 @@ void test_diff_workdir__to_tree(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(15, exp.files);
 		cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
@@ -278,10 +278,10 @@ void test_diff_workdir__to_tree(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(16, exp.files);
 		cl_assert_equal_i(5, exp.file_status[GIT_DELTA_ADDED]);
@@ -312,7 +312,7 @@ void test_diff_workdir__to_tree(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(16, exp.files);
 	cl_assert_equal_i(5, exp.file_status[GIT_DELTA_DELETED]);
@@ -359,9 +359,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, NULL, NULL, &exp));
+				diff, diff_file_cb, NULL, NULL, NULL, &exp));
 		else
-			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 		cl_assert_equal_i(13, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -382,9 +382,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, NULL, NULL, &exp));
+				diff, diff_file_cb, NULL, NULL, NULL, &exp));
 		else
-			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -405,9 +405,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, NULL, NULL, &exp));
+				diff, diff_file_cb, NULL, NULL, NULL, &exp));
 		else
-			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 		cl_assert_equal_i(3, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -428,9 +428,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, NULL, NULL, &exp));
+				diff, diff_file_cb, NULL, NULL, NULL, &exp));
 		else
-			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 		cl_assert_equal_i(2, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -465,10 +465,10 @@ void test_diff_workdir__filemode_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(0, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -488,10 +488,10 @@ void test_diff_workdir__filemode_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -521,7 +521,7 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -536,8 +536,8 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
 
 	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_git_pass(git_diff_foreach(diff, 
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -580,10 +580,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -601,10 +601,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff_w2i, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_w2i, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff_w2i, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_w2i, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -624,10 +624,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -666,10 +666,10 @@ void test_diff_workdir__eof_newline_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(0, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -693,10 +693,10 @@ void test_diff_workdir__eof_newline_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -720,10 +720,10 @@ void test_diff_workdir__eof_newline_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -913,7 +913,7 @@ void test_diff_workdir__submodules(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	/* so "git diff 873585" returns:
 	 *  M   .gitmodules
@@ -991,7 +991,7 @@ void test_diff_workdir__to_null_tree(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(exp.files, exp.file_status[GIT_DELTA_UNTRACKED]);
 
@@ -1080,7 +1080,7 @@ void test_diff_workdir__to_index_issue_1397(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.hunks);
@@ -1096,7 +1096,7 @@ void test_diff_workdir__to_index_issue_1397(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1133,7 +1133,7 @@ void test_diff_workdir__to_tree_issue_1397(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.hunks);
@@ -1149,7 +1149,7 @@ void test_diff_workdir__to_tree_issue_1397(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.hunks);
@@ -1203,7 +1203,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1223,7 +1223,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1243,7 +1243,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1267,7 +1267,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1290,7 +1290,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1310,7 +1310,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1333,7 +1333,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1354,7 +1354,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1505,7 +1505,7 @@ void test_diff_workdir__with_stale_index(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(17, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1527,7 +1527,7 @@ void test_diff_workdir__with_stale_index(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	git_diff_free(diff);
 
@@ -1568,7 +1568,7 @@ static void basic_diff_status(git_diff **out, const git_diff_options *opts)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		*out, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		*out, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(13, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
diff --git a/tests/stress/diff.c b/tests/stress/diff.c
index 0dda44d30..a3ba4fab3 100644
--- a/tests/stress/diff.c
+++ b/tests/stress/diff.c
@@ -37,7 +37,7 @@ static void test_with_many(int expected_new)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, NULL, NULL, &exp));
+		diff, diff_file_cb, NULL, NULL, NULL, &exp));
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(expected_new + 1, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(expected_new + 2, exp.files);
@@ -47,7 +47,7 @@ static void test_with_many(int expected_new)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, NULL, NULL, &exp));
+		diff, diff_file_cb, NULL, NULL, NULL, &exp));
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 	cl_assert_equal_i(expected_new, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(expected_new + 1, exp.files);
@@ -63,7 +63,7 @@ static void test_with_many(int expected_new)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, NULL, NULL, &exp));
+		diff, diff_file_cb, NULL, NULL, NULL, &exp));
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(expected_new + 1, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(expected_new + 2, exp.files);
@@ -73,7 +73,7 @@ static void test_with_many(int expected_new)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, NULL, NULL, &exp));
+		diff, diff_file_cb, NULL, NULL, NULL, &exp));
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 	cl_assert_equal_i(expected_new, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(expected_new + 1, exp.files);