Use chained reader like interface for filters instead of process interface.

1 files changed, 75 insertions, 53 deletions

diff --git a/fitz/stm_open.c b/fitz/stm_open.c
index e70a4580..d59062cc 100644
--- a/fitz/stm_open.c
+++ b/fitz/stm_open.c
@@ -1,21 +1,27 @@
 #include "fitz.h"
 
-static fz_stream *
-fz_newstream(int kind)
+fz_stream *
+fz_newstream(void *state,
+	int(*read)(fz_stream *stm, unsigned char *buf, int len),
+	void(*close)(fz_stream *stm))
 {
 	fz_stream *stm;
 
 	stm = fz_malloc(sizeof(fz_stream));
 
 	stm->refs = 1;
-	stm->kind = kind;
 	stm->dead = 0;
-	stm->error = fz_okay;
-	stm->buffer = nil;
+	stm->pos = 0;
+
+	stm->bp = stm->buf;
+	stm->rp = stm->bp;
+	stm->wp = stm->bp;
+	stm->ep = stm->buf + sizeof stm->buf;
 
-	stm->chain = nil;
-	stm->filter = nil;
-	stm->file = -1;
+	stm->state = state;
+	stm->read = read;
+	stm->close = close;
+	stm->seek = nil;
 
 	return stm;
 }
@@ -28,81 +34,97 @@ fz_keepstream(fz_stream *stm)
 }
 
 void
-fz_dropstream(fz_stream *stm)
+fz_close(fz_stream *stm)
 {
 	stm->refs --;
 	if (stm->refs == 0)
 	{
-		if (stm->error)
-		{
-			fz_catch(stm->error, "dropped unhandled ioerror");
-			stm->error = fz_okay;
-		}
-
-		switch (stm->kind)
-		{
-		case FZ_SFILE:
-			close(stm->file);
-			break;
-		case FZ_SFILTER:
-			fz_dropfilter(stm->filter);
-			fz_dropstream(stm->chain);
-			break;
-		case FZ_SBUFFER:
-			break;
-		}
-
-		fz_dropbuffer(stm->buffer);
+		if (stm->close)
+			stm->close(stm);
 		fz_free(stm);
 	}
 }
 
-fz_stream *
-fz_openfile(int fd)
+/* File stream */
+
+static int readfile(fz_stream *stm, unsigned char *buf, int len)
 {
-	fz_stream *stm;
+	int n = read(*(int*)stm->state, buf, len);
+	if (n < 0)
+		return fz_throw("read error: %s", strerror(errno));
+	return n;
+}
 
-	stm = fz_newstream(FZ_SFILE);
-	stm->buffer = fz_newbuffer(FZ_BUFSIZE);
-	stm->file = fd;
+static void seekfile(fz_stream *stm, int offset, int whence)
+{
+	int n = lseek(*(int*)stm->state, offset, whence);
+	if (n < 0)
+		fz_warn("cannot lseek: %s", strerror(errno));
+	stm->pos = n;
+	stm->rp = stm->bp;
+	stm->wp = stm->bp;
+}
 
-	return stm;
+static void closefile(fz_stream *stm)
+{
+	int n = close(*(int*)stm->state);
+	if (n < 0)
+		fz_warn("close error: %s", strerror(errno));
+	fz_free(stm->state);
 }
 
 fz_stream *
-fz_openfilter(fz_filter *flt, fz_stream *src)
+fz_openfile(int fd)
 {
 	fz_stream *stm;
+	int *state;
+
+	state = fz_malloc(sizeof(int));
+	*state = fd;
 
-	stm = fz_newstream(FZ_SFILTER);
-	stm->buffer = fz_newbuffer(FZ_BUFSIZE);
-	stm->chain = fz_keepstream(src);
-	stm->filter = fz_keepfilter(flt);
+	stm = fz_newstream(state, readfile, closefile);
+	stm->seek = seekfile;
 
 	return stm;
 }
 
-fz_stream *
-fz_openbuffer(fz_buffer *buf)
+/* Memory stream */
+
+static int readbuffer(fz_stream *stm, unsigned char *buf, int len)
 {
-	fz_stream *stm;
+	return 0;
+}
 
-	stm = fz_newstream(FZ_SBUFFER);
-	stm->buffer = fz_keepbuffer(buf);
-	stm->buffer->eof = 1;
+static void seekbuffer(fz_stream *stm, int offset, int whence)
+{
+	if (whence == 0)
+		stm->rp = stm->bp + offset;
+	if (whence == 1)
+		stm->rp += offset;
+	if (whence == 2)
+		stm->rp = stm->wp - offset;
+	stm->rp = CLAMP(stm->rp, stm->bp, stm->wp);
+}
 
-	return stm;
+static void closebuffer(fz_stream *stm)
+{
+	fz_dropbuffer(stm->state);
 }
 
 fz_stream *
-fz_openmemory(unsigned char *mem, int len)
+fz_openbuffer(fz_buffer *buf)
 {
-	fz_buffer *buf;
 	fz_stream *stm;
 
-	buf = fz_newbufferwithmemory(mem, len);
-	stm = fz_openbuffer(buf);
-	fz_dropbuffer(buf);
+	stm = fz_newstream(fz_keepbuffer(buf), readbuffer, closebuffer);
+	stm->seek = seekbuffer;
+
+	stm->bp = buf->data;
+	stm->rp = buf->data;
+	stm->wp = buf->data + buf->len;
+	stm->ep = buf->data + buf->len;
+
+	stm->pos = buf->len;
 
 	return stm;
 }