split mupdf/image and added colorspace resource lookup to inline images

7 files changed, 215 insertions, 192 deletions

diff --git a/Jamfile b/Jamfile
index 039dcbc0..328b62a1 100644
--- a/Jamfile
+++ b/Jamfile
@@ -118,7 +118,8 @@ Library libmupdf :
 	mupdf/font.c
 	mupdf/type3.c
 	mupdf/colorspace.c
-	mupdf/image.c
+	mupdf/image1.c
+	mupdf/image2.c
 	mupdf/xobject.c
 	mupdf/pattern.c
 	mupdf/resources.c
diff --git a/TODO b/TODO
index cd252006..7f95264b 100644
--- a/TODO
+++ b/TODO
@@ -27,6 +27,7 @@ parser
 	- resource dict generate fake ids
 	- try to clean up colorspace/material handling in interpreter
 	- annotations and destinations (for links and outline)
+	- BPC 2, 4
 
 clean up
 	- make source ansi c89 / pedantic
diff --git a/include/mupdf/rsrc.h b/include/mupdf/rsrc.h
index eaf20fb2..898ff8c5 100644
--- a/include/mupdf/rsrc.h
+++ b/include/mupdf/rsrc.h
@@ -96,8 +96,9 @@ struct pdf_image_s
 	fz_buffer *samples;
 };
 
-fz_error *pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict, fz_file *file);
+fz_error *pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict, fz_file *file);
 fz_error *pdf_loadimage(pdf_image **imgp, pdf_xref *xref, fz_obj *obj, fz_obj *stm);
+fz_error *pdf_loadtile(fz_image *image, fz_pixmap *tile);
 
 /*
  * CMap and Font
diff --git a/mupdf/image.c b/mupdf/image1.c
index 8d8f60a8..44d93eda 100644
--- a/mupdf/image.c
+++ b/mupdf/image1.c
@@ -9,189 +9,8 @@ void pdf_dropimage(fz_image *fzimg)
 		fz_dropimage(img->mask);
 }
 
-static inline int getbit(const unsigned char *buf, int x)
-{
-	return ( buf[x >> 3] >> ( 7 - (x & 7) ) ) & 1;
-}
-
-static void loadtile1(pdf_image *src, fz_pixmap *dst, int n)
-{
-	int x, y, k;
-	for (y = dst->y; y < dst->y + dst->h; y++)
-	{
-		unsigned char *s = src->samples->bp + y * src->stride;
-		unsigned char *d = dst->samples + y * dst->w * dst->n;
-		for (x = dst->x; x < dst->x + dst->w; x++)
-		{
-			for (k = 0; k < n; k++)
-				d[x * n + k] = getbit(s, x * n + k);
-		}
-	}
-}
-
-static void loadtile1a(pdf_image *src, fz_pixmap *dst, int n)
-{
-	int x, y, k;
-	for (y = dst->y; y < dst->y + dst->h; y++)
-	{
-		unsigned char *s = src->samples->bp + y * src->stride;
-		unsigned char *d = dst->samples + y * dst->w * dst->n;
-		for (x = dst->x; x < dst->x + dst->w; x++)
-		{
-			d[x * (n+1) + 0] = 1;
-			for (k = 0; k < n; k++)
-				d[x * (n+1) + k + 1] = getbit(s, x * n + k);
-		}
-	}
-}
-
-static void loadtile8(pdf_image *src, fz_pixmap *dst, int n)
-{
-	int x, y, k;
-	for (y = dst->y; y < dst->y + dst->h; y++)
-	{
-		unsigned char *s = src->samples->bp + y * src->stride;
-		unsigned char *d = dst->samples + y * dst->w * dst->n;
-		for (x = dst->x; x < dst->x + dst->w; x++)
-			for (k = 0; k < n; k++)
-				*d++ = *s++;
-	}
-}
-
-static void loadtile8a(pdf_image *src, fz_pixmap *dst, int n)
-{
-	int x, y, k;
-	for (y = dst->y; y < dst->y + dst->h; y++)
-	{
-		unsigned char *s = src->samples->bp + y * src->stride;
-		unsigned char *d = dst->samples + y * dst->w * dst->n;
-		for (x = dst->x; x < dst->x + dst->w; x++)
-		{
-			*d++ = 255;
-			for (k = 0; k < n; k++)
-				*d++ = *s++;
-		}
-	}
-}
-
-static void
-decodetile(fz_pixmap *pix, int bpc, int skip, float *decode)
-{
-	unsigned char table[32][256];
-	float invtwon = 1.0 / ((1 << bpc) - 1);
-	int x, y, k, i;
-
-	for (i = 0; i < (1 << bpc); i++)
-	{
-		if (skip)
-			table[0][i] = (i * 255) * invtwon;
-		for (k = skip; k < pix->n; k++)
-		{
-			float min = decode[(k - skip) * 2 + 0];
-			float max = decode[(k - skip) * 2 + 1];
-			float f = min + i * (max - min) * invtwon;
-			table[k][i] = f * 255;
-		}
-	}
-
-	for (y = 0; y < pix->h; y++)
-	{
-		for (x = 0; x < pix->w; x++)
-		{
-			for (k = 0; k < pix->n; k++)
-			{
-				i = pix->samples[ (y * pix->w + x) * pix->n + k];
-				pix->samples[ (y * pix->w + x) * pix->n + k] = table[k][i];
-			}
-		}
-	}
-}
-
-static fz_error *
-loadtile(fz_image *img, fz_pixmap *tile)
-{
-	pdf_image *src = (pdf_image*)img;
-	fz_error *error;
-
-	assert(tile->n == img->n + 1);
-	assert(tile->x >= 0);
-	assert(tile->y >= 0);
-	assert(tile->x + tile->w <= img->w);
-	assert(tile->y + tile->h <= img->h);
-
-	if (src->indexed)
-	{
-		fz_pixmap *tmp;
-		int x, y, k, i;
-
-		error = fz_newpixmap(&tmp, tile->x, tile->y, tile->w, tile->h, 1);
-		if (error)
-			return error;
-
-		switch (src->bpc)
-		{
-		case 1: loadtile1(src, tmp, 1); break;
-	/*	case 2: loadtile2(src, tmp, 1); break; */
-	/*	case 4: loadtile4(src, tmp, 1); break; */
-		case 8: loadtile8(src, tmp, 1); break;
-		default:
-			return fz_throw("rangecheck: unsupported bit depth: %d", src->bpc);
-		}
-
-printf("  unpack n=%d\n", tile->n);
-		for (y = 0; y < tile->h; y++)
-		{
-			for (x = 0; x < tile->w; x++)
-			{
-				tile->samples[(y * tile->w + x) * tile->n] = 255;
-				i = tmp->samples[y * tile->w + x];
-				i = CLAMP(i, 0, src->indexed->high);
-				for (k = 0; k < src->indexed->base->n; k++)
-				{
-					tile->samples[(y * tile->w + x) * tile->n + k + 1] =
-						src->indexed->lookup[i * src->indexed->base->n + k];
-				}
-			}
-		}
-
-		fz_droppixmap(tmp);
-	}
-
-	else
-	{
-		if (img->a)
-		{
-			switch (src->bpc)
-			{
-			case 1: loadtile1(src, tile, img->n + img->a); break;
-		/*	case 2: loadtile2(src, tile, img->n + img->a); break; */
-		/*	case 4: loadtile4(src, tile, img->n + img->a); break; */
-			case 8: loadtile8(src, tile, img->n + img->a); break;
-			default:
-				return fz_throw("rangecheck: unsupported bit depth: %d", src->bpc);
-			}
-		}
-		else
-		{
-			switch (src->bpc)
-			{
-			case 1: loadtile1a(src, tile, img->n); break;
-		/*	case 2: loadtile2a(src, tile, img->n); break; */
-		/*	case 4: loadtile4a(src, tile, img->n); break; */
-			case 8: loadtile8a(src, tile, img->n); break;
-			default:
-				return fz_throw("rangecheck: unsupported bit depth: %d", src->bpc);
-			}
-		}
-
-		decodetile(tile, src->bpc, !img->a, src->decode);
-	}
-
-	return nil;
-}
-
 fz_error *
-pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict, fz_file *file)
+pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict, fz_file *file)
 {
 	fz_error *error;
 	pdf_image *img;
@@ -206,7 +25,7 @@ pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict, fz_file *fil
 	if (!img)
 		return fz_outofmem;
 
-	img->super.loadtile = loadtile;
+	img->super.loadtile = pdf_loadtile;
 	img->super.drop = pdf_dropimage;
 	img->super.n = 0;
 	img->super.a = 0;
@@ -229,9 +48,25 @@ pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict, fz_file *fil
 
 	if (cs)
 	{
-		error = pdf_loadcolorspace(&img->super.cs, xref, cs);
-		if (error)
-			return error;
+		img->super.cs = nil;
+
+		if (fz_isname(cs))
+		{
+			fz_obj *csd = fz_dictgets(rdb, "ColorSpace");
+			if (csd)
+			{
+				fz_obj *cso = fz_dictget(csd, cs);
+				img->super.cs = pdf_findresource(xref->rcolorspace, cso);
+			}
+		}
+
+		if (!img->super.cs)
+		{
+			error = pdf_loadcolorspace(&img->super.cs, xref, cs);
+			if (error)
+				return error;
+		}
+
 		img->super.n = img->super.cs->n;
 		img->super.a = 0;
 		if (!strcmp(img->super.cs->name, "Indexed"))
@@ -484,7 +319,7 @@ pdf_loadimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 	 * Create image object
 	 */
 
-	img->super.loadtile = loadtile;
+	img->super.loadtile = pdf_loadtile;
 	img->super.drop = pdf_dropimage;
 	img->super.cs = cs;
 	img->super.w = w;
diff --git a/mupdf/image2.c b/mupdf/image2.c
new file mode 100644
index 00000000..dde40926
--- /dev/null
+++ b/mupdf/image2.c
@@ -0,0 +1,184 @@
+#include <fitz.h>
+#include <mupdf.h>
+
+static inline int getbit(const unsigned char *buf, int x)
+{
+	return ( buf[x >> 3] >> ( 7 - (x & 7) ) ) & 1;
+}
+
+static void loadtile1(pdf_image *src, fz_pixmap *dst, int n)
+{
+	int x, y, k;
+	for (y = dst->y; y < dst->y + dst->h; y++)
+	{
+		unsigned char *s = src->samples->bp + y * src->stride;
+		unsigned char *d = dst->samples + y * dst->w * dst->n;
+		for (x = dst->x; x < dst->x + dst->w; x++)
+		{
+			for (k = 0; k < n; k++)
+				d[x * n + k] = getbit(s, x * n + k);
+		}
+	}
+}
+
+static void loadtile1a(pdf_image *src, fz_pixmap *dst, int n)
+{
+	int x, y, k;
+	for (y = dst->y; y < dst->y + dst->h; y++)
+	{
+		unsigned char *s = src->samples->bp + y * src->stride;
+		unsigned char *d = dst->samples + y * dst->w * dst->n;
+		for (x = dst->x; x < dst->x + dst->w; x++)
+		{
+			d[x * (n+1) + 0] = 1;
+			for (k = 0; k < n; k++)
+				d[x * (n+1) + k + 1] = getbit(s, x * n + k);
+		}
+	}
+}
+
+static void loadtile8(pdf_image *src, fz_pixmap *dst, int n)
+{
+	int x, y, k;
+	for (y = dst->y; y < dst->y + dst->h; y++)
+	{
+		unsigned char *s = src->samples->bp + y * src->stride;
+		unsigned char *d = dst->samples + y * dst->w * dst->n;
+		for (x = dst->x; x < dst->x + dst->w; x++)
+			for (k = 0; k < n; k++)
+				*d++ = *s++;
+	}
+}
+
+static void loadtile8a(pdf_image *src, fz_pixmap *dst, int n)
+{
+	int x, y, k;
+	for (y = dst->y; y < dst->y + dst->h; y++)
+	{
+		unsigned char *s = src->samples->bp + y * src->stride;
+		unsigned char *d = dst->samples + y * dst->w * dst->n;
+		for (x = dst->x; x < dst->x + dst->w; x++)
+		{
+			*d++ = 255;
+			for (k = 0; k < n; k++)
+				*d++ = *s++;
+		}
+	}
+}
+
+static void
+decodetile(fz_pixmap *pix, int bpc, int skip, float *decode)
+{
+	unsigned char table[32][256];
+	float invtwon = 1.0 / ((1 << bpc) - 1);
+	int x, y, k, i;
+
+	for (i = 0; i < (1 << bpc); i++)
+	{
+		if (skip)
+			table[0][i] = (i * 255) * invtwon;
+		for (k = skip; k < pix->n; k++)
+		{
+			float min = decode[(k - skip) * 2 + 0];
+			float max = decode[(k - skip) * 2 + 1];
+			float f = min + i * (max - min) * invtwon;
+			table[k][i] = f * 255;
+		}
+	}
+
+	for (y = 0; y < pix->h; y++)
+	{
+		for (x = 0; x < pix->w; x++)
+		{
+			for (k = 0; k < pix->n; k++)
+			{
+				i = pix->samples[ (y * pix->w + x) * pix->n + k];
+				pix->samples[ (y * pix->w + x) * pix->n + k] = table[k][i];
+			}
+		}
+	}
+}
+
+fz_error *
+pdf_loadtile(fz_image *img, fz_pixmap *tile)
+{
+	pdf_image *src = (pdf_image*)img;
+	fz_error *error;
+
+	assert(tile->n == img->n + 1);
+	assert(tile->x >= 0);
+	assert(tile->y >= 0);
+	assert(tile->x + tile->w <= img->w);
+	assert(tile->y + tile->h <= img->h);
+
+	if (src->indexed)
+	{
+		fz_pixmap *tmp;
+		int x, y, k, i;
+
+		error = fz_newpixmap(&tmp, tile->x, tile->y, tile->w, tile->h, 1);
+		if (error)
+			return error;
+
+		switch (src->bpc)
+		{
+		case 1: loadtile1(src, tmp, 1); break;
+	/*	case 2: loadtile2(src, tmp, 1); break; */
+	/*	case 4: loadtile4(src, tmp, 1); break; */
+		case 8: loadtile8(src, tmp, 1); break;
+		default:
+			return fz_throw("rangecheck: unsupported bit depth: %d", src->bpc);
+		}
+
+printf("  unpack n=%d\n", tile->n);
+		for (y = 0; y < tile->h; y++)
+		{
+			for (x = 0; x < tile->w; x++)
+			{
+				tile->samples[(y * tile->w + x) * tile->n] = 255;
+				i = tmp->samples[y * tile->w + x];
+				i = CLAMP(i, 0, src->indexed->high);
+				for (k = 0; k < src->indexed->base->n; k++)
+				{
+					tile->samples[(y * tile->w + x) * tile->n + k + 1] =
+						src->indexed->lookup[i * src->indexed->base->n + k];
+				}
+			}
+		}
+
+		fz_droppixmap(tmp);
+	}
+
+	else
+	{
+		if (img->a)
+		{
+			switch (src->bpc)
+			{
+			case 1: loadtile1(src, tile, img->n + img->a); break;
+		/*	case 2: loadtile2(src, tile, img->n + img->a); break; */
+		/*	case 4: loadtile4(src, tile, img->n + img->a); break; */
+			case 8: loadtile8(src, tile, img->n + img->a); break;
+			default:
+				return fz_throw("rangecheck: unsupported bit depth: %d", src->bpc);
+			}
+		}
+		else
+		{
+			switch (src->bpc)
+			{
+			case 1: loadtile1a(src, tile, img->n); break;
+		/*	case 2: loadtile2a(src, tile, img->n); break; */
+		/*	case 4: loadtile4a(src, tile, img->n); break; */
+			case 8: loadtile8a(src, tile, img->n); break;
+			default:
+				return fz_throw("rangecheck: unsupported bit depth: %d", src->bpc);
+			}
+		}
+
+		decodetile(tile, src->bpc, !img->a, src->decode);
+	}
+
+	return nil;
+}
+
diff --git a/mupdf/interpret.c b/mupdf/interpret.c
index 5e0e12a9..6f6f1aaf 100644
--- a/mupdf/interpret.c
+++ b/mupdf/interpret.c
@@ -135,7 +135,7 @@ runxobject(pdf_csi *csi, pdf_xref *xref, pdf_xobject *xobj)
  */
 
 static fz_error *
-runinlineimage(pdf_csi *csi, pdf_xref *xref, fz_file *file, fz_obj *dict)
+runinlineimage(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_file *file, fz_obj *dict)
 {
 	fz_error *error;
 	pdf_image *img;
@@ -143,7 +143,7 @@ runinlineimage(pdf_csi *csi, pdf_xref *xref, fz_file *file, fz_obj *dict)
 	int token;
 	int len;
 
-	error = pdf_loadinlineimage(&img, xref, dict, file);
+	error = pdf_loadinlineimage(&img, xref, rdb, dict, file);
 	if (error)
 		return error;
 
@@ -1137,7 +1137,7 @@ pdf_runcsi(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_file *file)
 				/* read whitespace after ID keyword */
 				fz_readbyte(file);
 
-				error = runinlineimage(csi, xref, file, obj);
+				error = runinlineimage(csi, xref, rdb, file, obj);
 				fz_dropobj(obj);
 				if (error)
 					return error;
diff --git a/render/renderimage.c b/render/renderimage.c
index 0cd631aa..3d287dca 100644
--- a/render/renderimage.c
+++ b/render/renderimage.c
@@ -236,6 +236,7 @@ printf("  scale tile 1/%d x 1/%d\n", dx, dy);
 	else
 		tile2 = tile1;
 
+
 	bbox.min.x = 0;
 	bbox.min.y = 0;
 	bbox.max.x = 1;