Malloc cannot return null. Clean up streams and filters.

23 files changed, 248 insertions, 550 deletions

diff --git a/apps/common/pdfapp.c b/apps/common/pdfapp.c
index 7af22d04..935f79f4 100644
--- a/apps/common/pdfapp.c
+++ b/apps/common/pdfapp.c
@@ -302,7 +302,6 @@ static void pdfapp_gotouri(pdfapp_t *app, fz_obj *uri)
 
 static void pdfapp_gotopage(pdfapp_t *app, fz_obj *obj)
 {
-	fz_error error;
 	int page;
 
 	page = pdf_findpageobject(app->xref, obj);
diff --git a/apps/pdfextract.c b/apps/pdfextract.c
index 4f4fb24a..35833c0e 100644
--- a/apps/pdfextract.c
+++ b/apps/pdfextract.c
@@ -180,10 +180,8 @@ static void savefont(fz_obj *dict, int num, int gen)
         return;
     }
 
-    error = fz_newbuffer(&buf, 0);
-    if (error)
-        die(error);
-
+    buf = fz_newbuffer(0);
+  
     error = pdf_loadstream(&buf, xref, fz_tonum(stream), fz_togen(stream));
     if (error)
         die(error);
diff --git a/fitz/filt_aesd.c b/fitz/filt_aesd.c
index 9b4c0962..122a284d 100644
--- a/fitz/filt_aesd.c
+++ b/fitz/filt_aesd.c
@@ -11,13 +11,13 @@ struct fz_aesd_s
     int ivcount;
 };
 
-fz_error
-fz_newaesdfilter(fz_filter **fp, unsigned char *key, unsigned keylen)
+fz_filter *
+fz_newaesdfilter(unsigned char *key, unsigned keylen)
 {
     FZ_NEWFILTER(fz_aesd, f, aesdfilter);
     aes_setkey_dec(&f->aes, key, keylen * 8);
     f->ivcount = 0;
-    return fz_okay;
+    return (fz_filter *)f;
 }
 
 void
diff --git a/fitz/filt_arc4.c b/fitz/filt_arc4.c
index d3832ec0..f50f8e86 100644
--- a/fitz/filt_arc4.c
+++ b/fitz/filt_arc4.c
@@ -9,12 +9,12 @@ struct fz_arc4c_s
 	fz_arc4 arc4;
 };
 
-fz_error
-fz_newarc4filter(fz_filter **fp, unsigned char *key, unsigned keylen)
+fz_filter *
+fz_newarc4filter(unsigned char *key, unsigned keylen)
 {
 	FZ_NEWFILTER(fz_arc4c, f, arc4filter);
 	fz_arc4init(&f->arc4, key, keylen);
-	return fz_okay;
+	return (fz_filter *)f;
 }
 
 void
diff --git a/fitz/filt_basic.c b/fitz/filt_basic.c
index 12408b5e..4eea42bf 100644
--- a/fitz/filt_basic.c
+++ b/fitz/filt_basic.c
@@ -1,11 +1,11 @@
 #include "fitz_base.h"
 #include "fitz_stream.h"
 
-fz_error
-fz_newcopyfilter(fz_filter **fp)
+fz_filter *
+fz_newcopyfilter(void)
 {
     FZ_NEWFILTER(fz_filter, f, copyfilter);
-    return fz_okay;
+    return f;
 }
 
 void
@@ -49,13 +49,13 @@ struct fz_nullfilter_s
 	int cur;
 };
 
-fz_error
-fz_newnullfilter(fz_filter **fp, int len)
+fz_filter *
+fz_newnullfilter(int len)
 {
 	FZ_NEWFILTER(fz_nullfilter, f, nullfilter);
 	f->len = len;
 	f->cur = 0;
-	return fz_okay;
+	return (fz_filter *)f;
 }
 
 void
@@ -128,13 +128,13 @@ static inline int fromhex(int a)
 	return 0;
 }
 
-fz_error
-fz_newahxd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newahxd(fz_obj *params)
 {
 	FZ_NEWFILTER(fz_ahxd, f, ahxd);
 	f->odd = 0;
 	f->a = 0;
-	return fz_okay;
+	return (fz_filter *)f;
 }
 
 void
@@ -209,13 +209,13 @@ struct fz_a85d_s
 	int count;
 };
 
-fz_error
-fz_newa85d(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newa85d(fz_obj *params)
 {
 	FZ_NEWFILTER(fz_a85d, f, a85d);
 	f->word = 0;
 	f->count = 0;
-	return fz_okay;
+	return (fz_filter *)f;
 }
 
 void
@@ -315,11 +315,11 @@ o1:				*(out->wp+0) = f->word >> 24;
 	}
 }
 
-fz_error
-fz_newrld(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newrld(fz_obj *params)
 {
 	FZ_NEWFILTER(fz_filter, f, rld);
-	return fz_okay;
+	return f;
 }
 
 void
diff --git a/fitz/filt_dctd.c b/fitz/filt_dctd.c
index 4f7778e8..99c7821a 100644
--- a/fitz/filt_dctd.c
+++ b/fitz/filt_dctd.c
@@ -81,10 +81,9 @@ static void myskipinput(j_decompress_ptr cinfo, long n)
 	src->super.next_input_byte = in->rp;
 }
 
-fz_error
-fz_newdctd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newdctd(fz_obj *params)
 {
-	fz_error err;
 	fz_obj *obj;
 	int colortransform;
 
@@ -106,11 +105,8 @@ fz_newdctd(fz_filter **fp, fz_obj *params)
 	myiniterr(&d->err);
 	d->cinfo.err = (struct jpeg_error_mgr*) &d->err;
 
-	if (setjmp(d->err.jb)) {
-		err = fz_throw("cannot decode jpeg: %s", d->err.msg);
-		fz_free(d);
-		return err;
-	}
+	if (setjmp(d->err.jb))
+		fz_warn("cannot initialise jpeg: %s", d->err.msg);
 
 	/* create decompression object. this zeroes cinfo except for err. */
 	jpeg_create_decompress(&d->cinfo);
@@ -131,7 +127,7 @@ fz_newdctd(fz_filter **fp, fz_obj *params)
 	d->cinfo.dct_method = JDCT_FASTEST;
 	d->cinfo.do_fancy_upsampling = FALSE;
 
-	return fz_okay;
+	return (fz_filter *)d;
 }
 
 void
diff --git a/fitz/filt_faxd.c b/fitz/filt_faxd.c
index 7a5cb774..7a244dfa 100644
--- a/fitz/filt_faxd.c
+++ b/fitz/filt_faxd.c
@@ -165,8 +165,8 @@ struct fz_faxd_s
 	unsigned char *dst;
 };
 
-fz_error
-fz_newfaxd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newfaxd(fz_obj *params)
 {
 	fz_obj *obj;
 
@@ -216,24 +216,12 @@ fz_newfaxd(fz_filter **fp, fz_obj *params)
 	fax->eolc = 0;
 
 	fax->ref = fz_malloc(fax->stride);
-	if (!fax->ref)
-	{
-		fz_free(fax);
-		return fz_rethrow(-1, "out of memory: scanline buffer one");
-	}
-
 	fax->dst = fz_malloc(fax->stride);
-	if (!fax->dst)
-	{
-		fz_free(fax->ref);
-		fz_free(fax);
-		return fz_rethrow(-1, "out of memory: scanline buffer two");
-	}
 
 	memset(fax->ref, 0, fax->stride);
 	memset(fax->dst, 0, fax->stride);
 
-	return fz_okay;
+	return (fz_filter*)fz_okay;
 }
 
 void
diff --git a/fitz/filt_flate.c b/fitz/filt_flate.c
index 7bd2a448..65233e6d 100644
--- a/fitz/filt_flate.c
+++ b/fitz/filt_flate.c
@@ -23,10 +23,9 @@ zfree(void *opaque, void *ptr)
 	fz_free(ptr);
 }
 
-fz_error
-fz_newflated(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newflated(fz_obj *params)
 {
-	fz_error eo;
 	fz_obj *obj;
 	int zipfmt;
 	int ei;
@@ -57,12 +56,10 @@ fz_newflated(fz_filter **fp, fz_obj *params)
 
 	if (ei != Z_OK)
 	{
-		eo = fz_throw("zlib error: inflateInit: %s", f->z.msg);
-		fz_free(f);
-		return eo;
+		fz_warn("zlib error: inflateInit: %s", f->z.msg);
 	}
 
-	return fz_okay;
+	return (fz_filter*)f;
 }
 
 void
@@ -73,7 +70,7 @@ fz_dropflated(fz_filter *f)
 
 	err = inflateEnd(zp);
 	if (err != Z_OK)
-		fprintf(stderr, "inflateEnd: %s", zp->msg);
+		fz_warn("inflateEnd: %s", zp->msg);
 }
 
 fz_error
diff --git a/fitz/filt_lzwd.c b/fitz/filt_lzwd.c
index 3fb5a759..d57d399f 100644
--- a/fitz/filt_lzwd.c
+++ b/fitz/filt_lzwd.c
@@ -42,8 +42,8 @@ struct fz_lzwd_s
 	lzw_code table[NUMCODES];
 };
 
-fz_error
-fz_newlzwd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newlzwd(fz_obj *params)
 {
 	int i;
 
@@ -83,7 +83,7 @@ fz_newlzwd(fz_filter **fp, fz_obj *params)
 	lzw->oldcode = -1;
 	lzw->resume = 0;
 
-	return fz_okay;
+	return (fz_filter *)lzw;
 }
 
 void
diff --git a/fitz/filt_pipeline.c b/fitz/filt_pipeline.c
index eec24803..3340e5b0 100644
--- a/fitz/filt_pipeline.c
+++ b/fitz/filt_pipeline.c
@@ -16,15 +16,15 @@ struct fz_pipeline_s
 	int tailneedsin;
 };
 
-fz_error
-fz_chainpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail, fz_buffer *buf)
+fz_filter *
+fz_chainpipeline(fz_filter *head, fz_filter *tail, fz_buffer *buf)
 {
 	FZ_NEWFILTER(fz_pipeline, p, pipeline);
 	p->head = fz_keepfilter(head);
 	p->tail = fz_keepfilter(tail);
 	p->tailneedsin = 1;
 	p->buffer = fz_keepbuffer(buf);
-	return fz_okay;
+	return (fz_filter*)p;
 }
 
 void
@@ -38,25 +38,17 @@ fz_unchainpipeline(fz_filter *filter, fz_filter **oldfp, fz_buffer **oldbp)
 	fz_dropfilter(filter);
 }
 
-fz_error
-fz_newpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail)
+fz_filter *
+fz_newpipeline(fz_filter *head, fz_filter *tail)
 {
-	fz_error error;
-
 	FZ_NEWFILTER(fz_pipeline, p, pipeline);
 
-	error = fz_newbuffer(&p->buffer, FZ_BUFSIZE);
-	if (error)
-	{
-	    fz_free(p);
-	    return fz_rethrow(error, "cannot create buffer");
-	}
-
+	p->buffer = fz_newbuffer(FZ_BUFSIZE);
 	p->head = fz_keepfilter(head);
 	p->tail = fz_keepfilter(tail);
 	p->tailneedsin = 1;
 
-	return fz_okay;
+	return (fz_filter*)p;
 }
 
 void
@@ -90,13 +82,10 @@ head:
 	{
 		if (p->tailneedsin && !p->head->produced)
 		{
-			fz_error be = fz_okay;
 			if (p->buffer->rp > p->buffer->bp)
-				be = fz_rewindbuffer(p->buffer);
+				fz_rewindbuffer(p->buffer);
 			else
-				be = fz_growbuffer(p->buffer);
-			if (be)
-				return be;
+				fz_growbuffer(p->buffer);
 			goto head;
 		}
 		goto tail;
diff --git a/fitz/filt_predict.c b/fitz/filt_predict.c
index 77e03799..b86b2515 100644
--- a/fitz/filt_predict.c
+++ b/fitz/filt_predict.c
@@ -21,8 +21,8 @@ struct fz_predict_s
 	unsigned char *ref;
 };
 
-fz_error
-fz_newpredictd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newpredictd(fz_obj *params)
 {
 	fz_obj *obj;
 
@@ -42,8 +42,8 @@ fz_newpredictd(fz_filter **fp, fz_obj *params)
 	    p->predictor != 12 && p->predictor != 13 &&
 	    p->predictor != 14 && p->predictor != 15)
 	{
-	    fz_free(p);
-	    return fz_throw("invalid predictor");
+		fz_warn("invalid predictor: %d", p->predictor);
+		p->predictor = 1;
 	}
 
 	obj = fz_dictgets(params, "Columns");
@@ -64,11 +64,6 @@ fz_newpredictd(fz_filter **fp, fz_obj *params)
 	if (p->predictor >= 10)
 	{
 		p->ref = fz_malloc(p->stride);
-		if (!p->ref)
-		{
-			fz_free(p);
-			return fz_rethrow(-1, "out of memory: scanline buffer");
-		}
 		memset(p->ref, 0, p->stride);
 	}
 	else
@@ -76,7 +71,7 @@ fz_newpredictd(fz_filter **fp, fz_obj *params)
 		p->ref = nil;
 	}
 
-	return fz_okay;
+	return (fz_filter*)p;
 }
 
 void
diff --git a/fitz/fitz_base.h b/fitz/fitz_base.h
index e5dce5f9..ecced36e 100644
--- a/fitz/fitz_base.h
+++ b/fitz/fitz_base.h
@@ -159,13 +159,16 @@ extern unsigned fz_cpuflags;
 
 #define STRIDE(n, bcp) (((bpc) * (n) + 7) / 8)
 
-/* plan9 stuff for utf-8 and path munging */
+/* plan9 stuff for utf-8 */
 int chartorune(int *rune, char *str);
 int runetochar(char *str, int *rune);
 int runelen(long c);
 int runenlen(int *r, int nrune);
 int fullrune(char *str, int n);
 
+/*
+ * Error handling.
+ */
 typedef int fz_error;
 
 extern char fz_errorbuf[];
@@ -205,6 +208,10 @@ int fz_hashlen(fz_hashtable *table);
 void *fz_hashgetkey(fz_hashtable *table, int idx);
 void *fz_hashgetval(fz_hashtable *table, int idx);
 
+/*
+ * Math and geometry
+ */
+
 /* multiply 8-bit fixpoint (0..1) so that 0*0==0 and 255*255==255 */
 #define fz_mul255(a,b) (((a) * ((b) + 1)) >> 8)
 #define fz_floor(x) floor(x)
diff --git a/fitz/fitz_stream.h b/fitz/fitz_stream.h
index fc8eb023..7328b6d1 100644
--- a/fitz/fitz_stream.h
+++ b/fitz/fitz_stream.h
@@ -163,11 +163,11 @@ struct fz_buffer_s
 	int eof;
 };
 
-fz_error fz_newbuffer(fz_buffer **bufp, int size);
-fz_error fz_newbufferwithmemory(fz_buffer **bufp, unsigned char *data, int size);
+fz_buffer * fz_newbuffer(int size);
+fz_buffer * fz_newbufferwithmemory(unsigned char *data, int size);
 
-fz_error fz_rewindbuffer(fz_buffer *buf);
-fz_error fz_growbuffer(fz_buffer *buf);
+void fz_rewindbuffer(fz_buffer *buf);
+void fz_growbuffer(fz_buffer *buf);
 
 fz_buffer *fz_keepbuffer(fz_buffer *buf);
 void fz_dropbuffer(fz_buffer *buf);
@@ -182,7 +182,7 @@ void fz_dropbuffer(fz_buffer *buf);
  *    ioneedout -- output buffer exhausted, please provide more space (ep-wp)
  *    iodone -- finished, please never call me again. ever!
  * or...
- *    any other error object -- oops, something blew up.
+ *    any other error code -- oops, something blew up.
  *
  * To make using the filter easier, three variables are updated:
  *    produced -- if we actually produced any new data
@@ -208,20 +208,18 @@ typedef struct fz_filter_s fz_filter;
  * Evil looking macro to create an initialize a filter struct.
  */
 
-#define FZ_NEWFILTER(TYPE,VAR,NAME)                                         \
-	fz_error fz_process ## NAME (fz_filter*,fz_buffer*,fz_buffer*);   \
-	void fz_drop ## NAME (fz_filter*);                                  \
-	TYPE *VAR;                                                          \
-	*fp = fz_malloc(sizeof(TYPE));                                      \
-	if (!*fp) return fz_throw("outofmem: %s filter struct", #NAME);     \
-	(*fp)->refs = 1;                                                    \
-	(*fp)->process = fz_process ## NAME ;                               \
-	(*fp)->drop = fz_drop ## NAME ;                                     \
-	(*fp)->consumed = 0;                                                \
-	(*fp)->produced = 0;                                                \
-	(*fp)->count = 0;                                                   \
-	(*fp)->done = 0;                                                    \
-	VAR = (TYPE*) *fp
+#define FZ_NEWFILTER(TYPE,VAR,NAME) \
+	fz_error fz_process ## NAME (fz_filter*,fz_buffer*,fz_buffer*); \
+	void fz_drop ## NAME (fz_filter*); \
+	TYPE *VAR; \
+	VAR = fz_malloc(sizeof(TYPE));	 \
+	((fz_filter*)VAR)->refs = 1; \
+	((fz_filter*)VAR)->process = fz_process ## NAME ;  \
+	((fz_filter*)VAR)->drop = fz_drop ## NAME ;  \
+	((fz_filter*)VAR)->consumed = 0;  \
+	((fz_filter*)VAR)->produced = 0; \
+	((fz_filter*)VAR)->count = 0; \
+	((fz_filter*)VAR)->done = 0;
 
 struct fz_filter_s
 {
@@ -238,27 +236,27 @@ fz_error fz_process(fz_filter *f, fz_buffer *in, fz_buffer *out);
 fz_filter *fz_keepfilter(fz_filter *f);
 void fz_dropfilter(fz_filter *f);
 
-fz_error fz_newpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail);
-fz_error fz_chainpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail, fz_buffer *buf);
+fz_filter * fz_newpipeline(fz_filter *head, fz_filter *tail);
+fz_filter * fz_chainpipeline(fz_filter *head, fz_filter *tail, fz_buffer *buf);
 void fz_unchainpipeline(fz_filter *pipe, fz_filter **oldfp, fz_buffer **oldbp);
 
 /* stop and reverse! special case needed for postscript only */
 void fz_pushbackahxd(fz_filter *filter, fz_buffer *in, fz_buffer *out, int n);
 
-fz_error fz_newnullfilter(fz_filter **fp, int len);
-fz_error fz_newcopyfilter(fz_filter **fp);
-fz_error fz_newarc4filter(fz_filter **fp, unsigned char *key, unsigned keylen);
-fz_error fz_newaesdfilter(fz_filter **fp, unsigned char *key, unsigned keylen);
-fz_error fz_newa85d(fz_filter **filterp, fz_obj *param);
-fz_error fz_newahxd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newrld(fz_filter **filterp, fz_obj *param);
-fz_error fz_newdctd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newfaxd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newflated(fz_filter **filterp, fz_obj *param);
-fz_error fz_newlzwd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newpredictd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newjbig2d(fz_filter **filterp, fz_obj *param);
-fz_error fz_newjpxd(fz_filter **filterp, fz_obj *param);
+fz_filter * fz_newnullfilter(int len);
+fz_filter * fz_newcopyfilter();
+fz_filter * fz_newarc4filter(unsigned char *key, unsigned keylen);
+fz_filter * fz_newaesdfilter(unsigned char *key, unsigned keylen);
+fz_filter * fz_newa85d(fz_obj *param);
+fz_filter * fz_newahxd(fz_obj *param);
+fz_filter * fz_newrld(fz_obj *param);
+fz_filter * fz_newdctd(fz_obj *param);
+fz_filter * fz_newfaxd(fz_obj *param);
+fz_filter * fz_newflated(fz_obj *param);
+fz_filter * fz_newlzwd(fz_obj *param);
+fz_filter * fz_newpredictd(fz_obj *param);
+fz_filter * fz_newjbig2d(fz_obj *param);
+fz_filter * fz_newjpxd(fz_obj *param);
 
 fz_error fz_setjbig2dglobalstream(fz_filter *filter, unsigned char *buf, int len);
 
@@ -349,13 +347,9 @@ struct fz_stream_s
  */
 
 fz_error fz_openrfile(fz_stream **stmp, char *filename);
-
-/* write to memory buffers! */
-fz_error fz_openrmemory(fz_stream **stmp, unsigned char *mem, int len);
-fz_error fz_openrbuffer(fz_stream **stmp, fz_buffer *buf);
-
-/* almost like fork() exec() pipe() */
-fz_error fz_openrfilter(fz_stream **stmp, fz_filter *flt, fz_stream *chain);
+fz_stream * fz_openrmemory(unsigned char *mem, int len);
+fz_stream * fz_openrbuffer(fz_buffer *buf);
+fz_stream * fz_openrfilter(fz_filter *flt, fz_stream *chain);
 
 /*
  * Functions that are common to both input and output streams.
@@ -376,8 +370,8 @@ fz_error fz_rseek(fz_stream *stm, int offset, int whence);
 
 fz_error fz_readimp(fz_stream *stm);
 fz_error fz_read(int *np, fz_stream *stm, unsigned char *buf, int len);
-fz_error fz_readall(fz_buffer **bufp, fz_stream *stm, int sizehint);
 fz_error fz_readline(fz_stream *stm, char *buf, int max);
+fz_buffer * fz_readall(fz_stream *stm, int sizehint);
 
 /*
  * Error handling when reading with readbyte/peekbyte is non-standard.
diff --git a/fitz/stm_buffer.c b/fitz/stm_buffer.c
index 102d7327..024dbea9 100644
--- a/fitz/stm_buffer.c
+++ b/fitz/stm_buffer.c
@@ -1,51 +1,38 @@
 #include "fitz_base.h"
 #include "fitz_stream.h"
 
-fz_error
-fz_newbuffer(fz_buffer **bp, int size)
+fz_buffer *
+fz_newbuffer(int size)
 {
 	fz_buffer *b;
 
-	b = *bp = fz_malloc(sizeof(fz_buffer));
-	if (!b)
-		return fz_rethrow(-1, "out of memory: buffer struct");
-
+	b = fz_malloc(sizeof(fz_buffer));
 	b->refs = 1;
 	b->ownsdata = 1;
 	b->bp = fz_malloc(size);
-	if (!b->bp)
-	{
-		fz_free(b);
-		return fz_rethrow(-1, "out of memory: buffer memory");
-	}
-
 	b->rp = b->bp;
 	b->wp = b->bp;
 	b->ep = b->bp + size;
 	b->eof = 0;
 
-	return fz_okay;
+	return b;
 }
 
-fz_error
-fz_newbufferwithmemory(fz_buffer **bp, unsigned char *data, int size)
+fz_buffer *
+fz_newbufferwithmemory(unsigned char *data, int size)
 {
 	fz_buffer *b;
 
-	b = *bp = fz_malloc(sizeof(fz_buffer));
-	if (!b)
-		return fz_rethrow(-1, "out of memory: buffer struct");
-
+	b = fz_malloc(sizeof(fz_buffer));
 	b->refs = 1;
 	b->ownsdata = 0;
 	b->bp = data;
-
 	b->rp = b->bp;
 	b->wp = b->bp + size;
 	b->ep = b->bp + size;
 	b->eof = 0;
 
-	return fz_okay;
+	return b;
 }
 
 fz_buffer *
@@ -66,7 +53,7 @@ fz_dropbuffer(fz_buffer *buf)
 	}
 }
 
-fz_error
+void
 fz_growbuffer(fz_buffer *buf)
 {
 	unsigned char *newbp;
@@ -76,30 +63,29 @@ fz_growbuffer(fz_buffer *buf)
 	int ep = buf->ep - buf->bp;
 
 	if (!buf->ownsdata)
-		return fz_throw("assert: grow borrowed memory");
-
+	{
+		 fz_warn("assert: grow borrowed memory");
+		return;
+	}
+	
 	newbp = fz_realloc(buf->bp, ep * 2);
-	if (!newbp)
-		return fz_rethrow(-1, "out of memory: resize buffer memory");
-
 	buf->bp = newbp;
 	buf->rp = buf->bp + rp;
 	buf->wp = buf->bp + wp;
 	buf->ep = buf->bp + ep * 2;
-
-	return fz_okay;
 }
 
-fz_error
+void
 fz_rewindbuffer(fz_buffer *buf)
 {
 	if (!buf->ownsdata)
-		return fz_throw("assert: rewind borrowed memory");
+	{
+		 fz_warn("assert: rewind borrowed memory");
+		return;
+	}
 
 	memmove(buf->bp, buf->rp, buf->wp - buf->rp);
 	buf->wp = buf->bp + (buf->wp - buf->rp);
 	buf->rp = buf->bp;
-
-	return fz_okay;
 }
 
diff --git a/fitz/stm_misc.c b/fitz/stm_misc.c
index 8e3ced42..7f7cf76f 100644
--- a/fitz/stm_misc.c
+++ b/fitz/stm_misc.c
@@ -72,33 +72,21 @@ static inline int fz_fillbuf(fz_stream *stm, fz_buffer *buf)
  * a freshly allocated buffer.
  */
 
-fz_error
-fz_readall(fz_buffer **bufp, fz_stream *stm, int sizehint)
+fz_buffer *
+fz_readall(fz_stream *stm, int sizehint)
 {
-	fz_error error;
 	fz_buffer *buf;
 
 	if (sizehint == 0)
 	    sizehint = 4 * 1024;
 
-	error = fz_newbuffer(&buf, sizehint);
-	if (error)
-	    return fz_rethrow(error, "cannot create scratch buffer");
+	buf = fz_newbuffer(sizehint);
 
 	while (fz_fillbuf(stm, buf) != EOF)
 	{
 		if (buf->wp == buf->ep)
-		{
-		    error = fz_growbuffer(buf);
-		    if (error)
-		    {
-			fz_dropbuffer(buf);
-			return fz_rethrow(error, "cannot resize scratch buffer");
-		    }
-		}
+			fz_growbuffer(buf);
 	}
 
-	*bufp = buf;
-	return fz_okay;
+	return buf;
 }
-
diff --git a/fitz/stm_open.c b/fitz/stm_open.c
index c1f73f48..0f9e94f8 100644
--- a/fitz/stm_open.c
+++ b/fitz/stm_open.c
@@ -11,8 +11,6 @@ newstm(int kind)
 	fz_stream *stm;
 
 	stm = fz_malloc(sizeof(fz_stream));
-	if (!stm)
-		return nil;
 
 	stm->refs = 1;
 	stm->kind = kind;
@@ -66,19 +64,11 @@ fz_dropstream(fz_stream *stm)
 
 fz_error fz_openrfile(fz_stream **stmp, char *path)
 {
-	fz_error error;
 	fz_stream *stm;
 
 	stm = newstm(FZ_SFILE);
-	if (!stm)
-		return fz_rethrow(-1, "out of memory: stream struct");
 
-	error = fz_newbuffer(&stm->buffer, FZ_BUFSIZE);
-	if (error)
-	{
-		fz_free(stm);
-		return fz_rethrow(error, "cannot create buffer");
-	}
+	stm->buffer = fz_newbuffer(FZ_BUFSIZE);
 
 	stm->file = open(path, O_BINARY | O_RDONLY, 0666);
 	if (stm->file < 0)
@@ -92,63 +82,37 @@ fz_error fz_openrfile(fz_stream **stmp, char *path)
 	return fz_okay;
 }
 
-fz_error fz_openrfilter(fz_stream **stmp, fz_filter *flt, fz_stream *src)
+fz_stream * fz_openrfilter(fz_filter *flt, fz_stream *src)
 {
-	fz_error error;
 	fz_stream *stm;
 
 	stm = newstm(FZ_SFILTER);
-	if (!stm)
-		return fz_rethrow(-1, "out of memory: stream struct");
-
-	error = fz_newbuffer(&stm->buffer, FZ_BUFSIZE);
-	if (error)
-	{
-		fz_free(stm);
-		return fz_rethrow(error, "cannot create buffer");
-	}
-
+	stm->buffer = fz_newbuffer(FZ_BUFSIZE);
 	stm->chain = fz_keepstream(src);
 	stm->filter = fz_keepfilter(flt);
 
-	*stmp = stm;
-	return fz_okay;
+	return stm;
 }
 
-fz_error fz_openrbuffer(fz_stream **stmp, fz_buffer *buf)
+fz_stream * fz_openrbuffer(fz_buffer *buf)
 {
 	fz_stream *stm;
 
 	stm = newstm(FZ_SBUFFER);
-	if (!stm)
-		return fz_rethrow(-1, "out of memory: stream struct");
-
 	stm->buffer = fz_keepbuffer(buf);
-
 	stm->buffer->eof = 1;
 
-	*stmp = stm;
-	return fz_okay;
+	return stm;
 }
 
-fz_error fz_openrmemory(fz_stream **stmp, unsigned char *mem, int len)
+fz_stream * fz_openrmemory(unsigned char *mem, int len)
 {
-	fz_error error;
 	fz_buffer *buf;
-
-	error = fz_newbufferwithmemory(&buf, mem, len);
-	if (error)
-		return fz_rethrow(error, "cannot create memory buffer");
-
-	error = fz_openrbuffer(stmp, buf);
-	if (error)
-	{
-		fz_dropbuffer(buf);
-		return fz_rethrow(error, "cannot open memory buffer stream");
-	}
-
+	fz_stream *stm;
+	
+	buf = fz_newbufferwithmemory(mem, len);
+	stm = fz_openrbuffer(buf);
 	fz_dropbuffer(buf);
 
-	return fz_okay;
+	return stm;
 }
-
diff --git a/fitz/stm_read.c b/fitz/stm_read.c
index adb79908..1dfa4648 100644
--- a/fitz/stm_read.c
+++ b/fitz/stm_read.c
@@ -20,22 +20,9 @@ fz_readimp(fz_stream *stm)
 	if (buf->eof)
 		return fz_okay;
 
-	error = fz_rewindbuffer(buf);
-	if (error)
-	{
-		stm->dead = 1;
-		return fz_rethrow(error, "cannot rewind output buffer");
-	}
-
+	fz_rewindbuffer(buf);
 	if (buf->ep - buf->wp == 0)
-	{
-		error = fz_growbuffer(buf);
-		if (error)
-		{
-			stm->dead = 1;
-			return fz_rethrow(error, "cannot grow output buffer");
-		}
-	}
+		fz_growbuffer(buf);
 
 	switch (stm->kind)
 	{
@@ -80,23 +67,9 @@ fz_readimp(fz_stream *stm)
 					return 0;
 
 				if (buf->rp > buf->bp)
-				{
-					error = fz_rewindbuffer(buf);
-					if (error)
-					{
-						stm->dead = 1;
-						return fz_rethrow(error, "cannot rewind buffer");
-					}
-				}
+					fz_rewindbuffer(buf);
 				else
-				{
-					error = fz_growbuffer(buf);
-					if (error)
-					{
-						stm->dead = 1;
-						return fz_rethrow(error, "cannot grow buffer");
-					}
-				}
+					fz_growbuffer(buf);
 			}
 
 			else if (reason == fz_iodone)
diff --git a/mupdf/mupdf.h b/mupdf/mupdf.h
index 325d068f..3235e0ec 100644
--- a/mupdf/mupdf.h
+++ b/mupdf/mupdf.h
@@ -103,7 +103,7 @@ fz_error pdf_newcrypt(pdf_crypt **cp, fz_obj *enc, fz_obj *id);
 void pdf_freecrypt(pdf_crypt *crypt);
 
 fz_error pdf_parsecryptfilter(pdf_cryptfilter *cf, fz_obj *dict, int defaultlength);
-fz_error pdf_cryptstream(fz_filter **fp, pdf_crypt *crypt, pdf_cryptfilter *cf, int num, int gen);
+fz_filter * pdf_cryptstream(pdf_crypt *crypt, pdf_cryptfilter *cf, int num, int gen);
 void pdf_cryptobj(pdf_crypt *crypt, fz_obj *obj, int num, int gen);
 
 int pdf_needspassword(pdf_xref *xref);
@@ -158,7 +158,7 @@ fz_error pdf_cacheobject(pdf_xref *, int oid, int gen);
 fz_error pdf_loadobject(fz_obj **objp, pdf_xref *, int oid, int gen);
 
 int pdf_isstream(pdf_xref *xref, int oid, int gen);
-fz_error pdf_buildinlinefilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj);
+fz_filter * pdf_buildinlinefilter(pdf_xref *xref, fz_obj *stmobj);
 fz_error pdf_loadrawstream(fz_buffer **bufp, pdf_xref *xref, int oid, int gen);
 fz_error pdf_loadstream(fz_buffer **bufp, pdf_xref *xref, int oid, int gen);
 fz_error pdf_openrawstream(fz_stream **stmp, pdf_xref *, int oid, int gen);
diff --git a/mupdf/pdf_crypt.c b/mupdf/pdf_crypt.c
index a973324f..13973326 100644
--- a/mupdf/pdf_crypt.c
+++ b/mupdf/pdf_crypt.c
@@ -598,39 +598,20 @@ pdf_cryptobj(pdf_crypt *crypt, fz_obj *obj, int num, int gen)
  *
  * Create filter suitable for de/encrypting a stream.
  */
-fz_error
-pdf_cryptstream(fz_filter **fp, pdf_crypt *crypt, pdf_cryptfilter *stmf, int num, int gen)
+fz_filter *
+pdf_cryptstream(pdf_crypt * crypt, pdf_cryptfilter * stmf, int num, int gen)
 {
-    fz_error error;
-    unsigned char key[16];
-    int len;
+	unsigned char key[16];
+	int len;
 
-    len = pdf_computeobjectkey(crypt, stmf, num, gen, key);
+	len = pdf_computeobjectkey(crypt, stmf, num, gen, key);
 
-    if (stmf->method == PDF_CRYPT_NONE)
-    {
-	error = fz_newcopyfilter(fp);
-	if (error)
-	    return fz_rethrow(error, "cannot create null crypt filter");
-	return fz_okay;
-    }
+	if (stmf->method == PDF_CRYPT_RC4)
+		return fz_newarc4filter(key, len);
 
-    if (stmf->method == PDF_CRYPT_RC4)
-    {
-	error = fz_newarc4filter(fp, key, len);
-	if (error)
-	    return fz_rethrow(error, "cannot create RC4 crypt filter");
-	return fz_okay;
-    }
-
-    if (stmf->method == PDF_CRYPT_AESV2)
-    {
-	error = fz_newaesdfilter(fp, key, len);
-	if (error)
-	    return fz_rethrow(error, "cannot create AES crypt filter");
-	return fz_okay;
-    }
+	if (stmf->method == PDF_CRYPT_AESV2)
+		return fz_newaesdfilter(key, len);
 
-    return fz_throw("unknown crypt method");
+	return fz_newcopyfilter();
 }
 
diff --git a/mupdf/pdf_image.c b/mupdf/pdf_image.c
index 6f5d1be9..21f05180 100644
--- a/mupdf/pdf_image.c
+++ b/mupdf/pdf_image.c
@@ -147,9 +147,7 @@ pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref,
 	f = fz_dictgetsa(dict, "Filter", "F");
 	if (!f || (fz_isarray(f) && fz_arraylen(f) == 0))
 	{
-		error = fz_newbuffer(&img->samples, img->super.h * img->stride);
-		if (error)
-			return error;
+		img->samples = fz_newbuffer(img->super.h * img->stride);
 
 		error = fz_read(&i, file, img->samples->bp, img->super.h * img->stride);
 		if (error)
@@ -161,20 +159,16 @@ pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref,
 	{
 		fz_stream *tempfile;
 
-		error = pdf_buildinlinefilter(&filter, xref, dict);
-		if (error)
-			return error;
+		filter = pdf_buildinlinefilter(xref, dict);
 
-		error = fz_openrfilter(&tempfile, filter, file);
-		if (error)
-			return error;
+		tempfile = fz_openrfilter(filter, file);
 
-		error = fz_readall(&img->samples, tempfile, img->stride * img->super.h);
+		img->samples = fz_readall(tempfile, img->stride * img->super.h);
+		fz_dropstream(tempfile);
 		if (error)
 			return error;
 
 		fz_dropfilter(filter);
-		fz_dropstream(tempfile);
 	}
 
 	/* 0 means opaque and 1 means transparent, so we invert to get alpha */
@@ -405,14 +399,7 @@ pdf_loadimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict)
 		/* don't treat truncated image as fatal - get as much as possible and
 		   fill the rest with 0 */
 		fz_buffer *buf;
-		error = fz_newbuffer(&buf, expectedsize);
-		if (error)
-		{
-			/* TODO: colorspace? */
-			fz_dropbuffer(img->samples);
-			fz_free(img);
-			return error;
-		}
+		buf = fz_newbuffer(expectedsize);
 		memset(buf->bp, 0, expectedsize);
 		memmove(buf->bp, img->samples->bp, realsize);
 		buf->wp = buf->bp + expectedsize;
diff --git a/mupdf/pdf_interpret.c b/mupdf/pdf_interpret.c
index 76755714..d2fc49d6 100644
--- a/mupdf/pdf_interpret.c
+++ b/mupdf/pdf_interpret.c
@@ -229,9 +229,7 @@ runxobject(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, pdf_xobject *xobj)
 
 	xobj->contents->rp = xobj->contents->bp;
 
-	error = fz_openrbuffer(&file, xobj->contents);
-	if (error)
-		return fz_rethrow(error, "cannot open XObject stream");
+	file = fz_openrbuffer(xobj->contents);
 
 	if (xobj->resources)
 		rdb = xobj->resources;
diff --git a/mupdf/pdf_page.c b/mupdf/pdf_page.c
index 9b42513d..072d663e 100644
--- a/mupdf/pdf_page.c
+++ b/mupdf/pdf_page.c
@@ -14,12 +14,7 @@ runone(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_obj *stmref)
 	if (error)
 		return fz_rethrow(error, "cannot load content stream (%d %d R)", fz_tonum(stmref), fz_togen(stmref));
 
-	error = fz_openrbuffer(&stm, buf);
-	if (error)
-	{
-		fz_dropbuffer(buf);
-		return fz_rethrow(error, "cannot open content buffer (read)");
-	}
+	stm = fz_openrbuffer(buf);
 
 	error = pdf_runcsi(csi, xref, rdb, stm);
 
@@ -47,9 +42,7 @@ runmany(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_obj *list)
 
     pdf_logpage("multiple content streams: %d\n", fz_arraylen(list));
 
-    error = fz_newbuffer(&big, 32 * 1024);
-    if (error)
-	return fz_rethrow(error, "cannot create content buffer");
+    big = fz_newbuffer(32 * 1024);
 
     for (i = 0; i < fz_arraylen(list); i++)
     {
@@ -65,13 +58,7 @@ runmany(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_obj *list)
 
 	while (big->wp + n + 1 > big->ep)
 	{
-	    error = fz_growbuffer(big);
-	    if (error)
-	    {
-		fz_dropbuffer(one);
-		fz_dropbuffer(big);
-		return fz_rethrow(error, "cannot load content stream part %d/%d", i + 1, fz_arraylen(list));
-	    }
+	    fz_growbuffer(big);
 	}
 
 	memcpy(big->wp, one->rp, n);
@@ -82,13 +69,8 @@ runmany(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_obj *list)
 	fz_dropbuffer(one);
     }
 
-    error = fz_openrbuffer(&file, big);
-    if (error)
-    {
-	fz_dropbuffer(big);
-	return fz_rethrow(error, "cannot open content buffer (read)");
-    }
-
+    file = fz_openrbuffer(big);
+ 
     error = pdf_runcsi(csi, xref, rdb, file);
     if (error)
     {
diff --git a/mupdf/pdf_stream.c b/mupdf/pdf_stream.c
index 4a5c8120..be0b5f99 100644
--- a/mupdf/pdf_stream.c
+++ b/mupdf/pdf_stream.c
@@ -55,128 +55,94 @@ pdf_streamhascrypt(fz_obj *stm)
 /*
  * Create a filter given a name and param dictionary.
  */
-static fz_error
-buildonefilter(fz_filter **fp, pdf_xref *xref, fz_obj *f, fz_obj *p, int num, int gen)
+static fz_filter *
+buildonefilter(pdf_xref * xref, fz_obj * f, fz_obj * p, int num, int gen)
 {
 	fz_filter *decompress;
 	fz_filter *predict;
+	fz_filter *pipe;
 	fz_error error;
 	char *s;
 
 	s = fz_toname(f);
 
 	if (!strcmp(s, "ASCIIHexDecode") || !strcmp(s, "AHx"))
-		error = fz_newahxd(fp, p);
+		return fz_newahxd(p);
 
 	else if (!strcmp(s, "ASCII85Decode") || !strcmp(s, "A85"))
-		error = fz_newa85d(fp, p);
+		return fz_newa85d(p);
 
 	else if (!strcmp(s, "CCITTFaxDecode") || !strcmp(s, "CCF"))
-		error = fz_newfaxd(fp, p);
+		return fz_newfaxd(p);
 
 	else if (!strcmp(s, "DCTDecode") || !strcmp(s, "DCT"))
-		error = fz_newdctd(fp, p);
+		return fz_newdctd(p);
 
 	else if (!strcmp(s, "RunLengthDecode") || !strcmp(s, "RL"))
-		error = fz_newrld(fp, p);
+		return fz_newrld(p);
 
 	else if (!strcmp(s, "FlateDecode") || !strcmp(s, "Fl"))
 	{
-		if (fz_isdict(p))
+		fz_obj *obj = fz_dictgets(p, "Predictor");
+		if (obj)
 		{
-			fz_obj *obj = fz_dictgets(p, "Predictor");
-			if (obj)
-			{
-				error = fz_newflated(&decompress, p);
-				if (error)
-					return fz_rethrow(error, "cannot create deflate filter");
-
-				error = fz_newpredictd(&predict, p);
-				if (error)
-				{
-					fz_dropfilter(decompress);
-					return fz_rethrow(error, "cannot create predictor filter");
-				}
-
-				error = fz_newpipeline(fp, decompress, predict);
-				fz_dropfilter(decompress);
-				fz_dropfilter(predict);
-				if (error)
-					return fz_rethrow(error, "cannot create pipeline filter");
-				return fz_okay;
-			}
+			decompress = fz_newflated(p);
+			predict = fz_newpredictd(p);
+			pipe = fz_newpipeline(decompress, predict);
+			fz_dropfilter(decompress);
+			fz_dropfilter(predict);
+			return pipe;
 		}
-		error = fz_newflated(fp, p);
+		return fz_newflated(p);
 	}
 
 	else if (!strcmp(s, "LZWDecode") || !strcmp(s, "LZW"))
 	{
-		if (fz_isdict(p))
+		fz_obj *obj = fz_dictgets(p, "Predictor");
+		if (obj)
 		{
-			fz_obj *obj = fz_dictgets(p, "Predictor");
-			if (obj)
-			{
-				error = fz_newlzwd(&decompress, p);
-				if (error)
-					return fz_rethrow(error, "cannot create lzwd filter");
-
-				error = fz_newpredictd(&predict, p);
-				if (error)
-				{
-					fz_dropfilter(decompress);
-					return fz_rethrow(error, "cannot create predictor filter");
-				}
-
-				error = fz_newpipeline(fp, decompress, predict);
-				fz_dropfilter(decompress);
-				fz_dropfilter(predict);
-				if (error)
-					return fz_rethrow(error, "cannot create pipeline filter");
-				return fz_okay;
-			}
+			decompress = fz_newlzwd(p);
+			predict = fz_newpredictd(p);
+			pipe = fz_newpipeline(decompress, predict);
+			fz_dropfilter(decompress);
+			fz_dropfilter(predict);
+			return pipe;
 		}
-		error = fz_newlzwd(fp, p);
+		return fz_newlzwd(p);
 	}
 
 #ifdef HAVE_JBIG2DEC
 	else if (!strcmp(s, "JBIG2Decode"))
 	{
-		if (fz_isdict(p))
+		fz_obj *obj = fz_dictgets(p, "JBIG2Globals");
+		if (obj)
 		{
-			fz_obj *obj = fz_dictgets(p, "JBIG2Globals");
-			if (obj)
-			{
-				fz_buffer *globals;
-
-				error = fz_newjbig2d(fp, p);
-				if (error)
-					return fz_rethrow(error, "cannot create jbig2 filter");
+			fz_buffer *globals;
+			fz_filter *dec;
+			
+			dec = fz_newjbig2d(p);
 
-				error = pdf_loadstream(&globals, xref, fz_tonum(obj), fz_togen(obj));
-				if (error)
-					return fz_rethrow(error, "cannot load jbig2 global segments");
-
-				error = fz_setjbig2dglobalstream(*fp, globals->rp, globals->wp - globals->rp);
+			error = pdf_loadstream(&globals, xref, fz_tonum(obj), fz_togen(obj));
+			if (error)
+				fz_catch(error, "cannot load jbig2 global segments");
+			else
+			{
+				error = fz_setjbig2dglobalstream(dec, globals->rp, globals->wp - globals->rp);
 				if (error)
-					return fz_rethrow(error, "cannot apply jbig2 global segments");
+					fz_catch(error, "cannot apply jbig2 global segments");
+			}
 
-				fz_dropbuffer(globals);
+			fz_dropbuffer(globals);
 
-				return fz_okay;
-			}
+			return dec;
 		}
-
-		error = fz_newjbig2d(fp, p);
+		return fz_newjbig2d(p);
 	}
 #endif
 
-#ifdef HAVE_JASPER
-	else if (!strcmp(s, "JPXDecode"))
-		error = fz_newjpxd(fp, p);
-#endif
 #ifdef HAVE_OPENJPEG
 	else if (!strcmp(s, "JPXDecode"))
-		error = fz_newjpxd(fp, p);
+		return fz_newjpxd(fp, p);
 #endif
 
 	else if (!strcmp(s, "Crypt"))
@@ -185,7 +151,10 @@ buildonefilter(fz_filter **fp, pdf_xref *xref, fz_obj *f, fz_obj *p, int num, in
 		fz_obj *name;
 
 		if (!xref->crypt)
-			return fz_throw("crypt filter in unencrypted document");
+		{
+			fz_warn("crypt filter in unencrypted document");
+			return fz_newcopyfilter();
+		}
 
 		name = fz_dictgets(p, "Name");
 		if (fz_isname(name) && strcmp(fz_toname(name), "Identity") != 0)
@@ -195,29 +164,16 @@ buildonefilter(fz_filter **fp, pdf_xref *xref, fz_obj *f, fz_obj *p, int num, in
 			{
 				error = pdf_parsecryptfilter(&cf, obj, xref->crypt->length);
 				if (error)
-					return fz_rethrow(error, "cannot parse crypt filter");
-
-				error = pdf_cryptstream(fp, xref->crypt, &cf, num, gen);
-				if (error)
-					return fz_rethrow(error, "cannot create crypt filter");
-				return fz_okay;
+					fz_catch(error, "cannot parse crypt filter");
+				else
+					return pdf_cryptstream(xref->crypt, &cf, num, gen);
 			}
 		}
-
-		error = fz_newcopyfilter(fp);
-		if (error)
-		    return fz_rethrow(error, "cannot create identity crypt filter");
-		return fz_okay;
-	}
-
-	else
-	{
-		return fz_throw("unknown filter name (%s)", s);
+		return fz_newcopyfilter();
 	}
 
-	if (error)
-		return fz_rethrow(error, "cannot create filter");
-	return fz_okay;
+	fz_warn("unknown filter name (%s)", s);
+	return fz_newcopyfilter();
 }
 
 /*
@@ -225,11 +181,10 @@ buildonefilter(fz_filter **fp, pdf_xref *xref, fz_obj *f, fz_obj *p, int num, in
  * If head is given, start filter chain with it.
  * Assume ownership of head.
  */
-static fz_error
-buildfilterchain(fz_filter **filterp, pdf_xref *xref, fz_filter *head,
+static fz_filter *
+buildfilterchain(pdf_xref *xref, fz_filter *head,
 	fz_obj *fs, fz_obj *ps, int num, int gen)
 {
-	fz_error error;
 	fz_filter *newhead;
 	fz_filter *tail;
 	fz_obj *f;
@@ -244,28 +199,19 @@ buildfilterchain(fz_filter **filterp, pdf_xref *xref, fz_filter *head,
 		else
 			p = nil;
 
-		error = buildonefilter(&tail, xref, f, p, num, gen);
-		if (error)
-			return fz_rethrow(error, "cannot create filter");
-
+		tail = buildonefilter(xref, f, p, num, gen);
 		if (head)
 		{
-			error = fz_newpipeline(&newhead, head, tail);
+			newhead = fz_newpipeline(head, tail);
 			fz_dropfilter(head);
 			fz_dropfilter(tail);
-			if (error)
-			{
-				fz_dropfilter(newhead);
-				return fz_rethrow(error, "cannot create pipeline filter");
-			}
 			head = newhead;
 		}
 		else
 			head = tail;
 	}
 
-	*filterp = head;
-	return fz_okay;
+	return head;
 }
 
 /*
@@ -273,10 +219,9 @@ buildfilterchain(fz_filter **filterp, pdf_xref *xref, fz_filter *head,
  * This is a null filter to constrain reading to the
  * stream length, followed by a decryption filter.
  */
-static fz_error
-buildrawfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int num, int gen)
+static fz_filter *
+buildrawfilter(pdf_xref *xref, fz_obj *stmobj, int num, int gen)
 {
-	fz_error error;
 	fz_filter *base;
 	fz_obj *stmlen;
 	int len;
@@ -285,50 +230,31 @@ buildrawfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int num, int
 	hascrypt = pdf_streamhascrypt(stmobj);
 
 	stmlen = fz_dictgets(stmobj, "Length");
-	if (!fz_isint(stmlen))
-		return fz_throw("corrupt stream length");
 	len = fz_toint(stmlen);
 
-	error = fz_newnullfilter(&base, len);
-	if (error)
-		return fz_rethrow(error, "cannot create null filter");
+	base = fz_newnullfilter(len);
 
 	if (xref->crypt && !hascrypt)
 	{
 		fz_filter *crypt;
 		fz_filter *pipe;
-
-		error = pdf_cryptstream(&crypt, xref->crypt, &xref->crypt->stmf, num, gen);
-		if (error)
-		{
-			fz_dropfilter(base);
-			return fz_rethrow(error, "cannot create decryption filter");
-		}
-
-		error = fz_newpipeline(&pipe, base, crypt);
+		crypt = pdf_cryptstream(xref->crypt, &xref->crypt->stmf, num, gen);
+		pipe = fz_newpipeline(base, crypt);
 		fz_dropfilter(base);
 		fz_dropfilter(crypt);
-		if (error)
-			return fz_rethrow(error, "cannot create pipeline filter");
-
-		*filterp = pipe;
-	}
-	else
-	{
-		*filterp = base;
+		return pipe;
 	}
 
-	return fz_okay;
+	return base;
 }
 
 /*
  * Construct a filter to decode a stream, without
  * constraining to stream length, and without decryption.
  */
-fz_error
-pdf_buildinlinefilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj)
+fz_filter *
+pdf_buildinlinefilter(pdf_xref *xref, fz_obj *stmobj)
 {
-	fz_error error;
 	fz_obj *filters;
 	fz_obj *params;
 
@@ -338,26 +264,20 @@ pdf_buildinlinefilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj)
 	if (filters)
 	{
 		if (fz_isname(filters))
-			error = buildonefilter(filterp, xref, filters, params, 0, 0);
-		else
-			error = buildfilterchain(filterp, xref, nil, filters, params, 0, 0);
+			return buildonefilter(xref, filters, params, 0, 0);
+		return buildfilterchain(xref, nil, filters, params, 0, 0);
 	}
-	else
-		error = fz_newnullfilter(filterp, -1);
 
-	if (error)
-		return fz_rethrow(error, "cannot create inline filter chain");
-	return fz_okay;
+	return fz_newcopyfilter();
 }
 
 /*
  * Construct a filter to decode a stream, constraining
  * to stream length and decrypting.
  */
-static fz_error
-pdf_buildfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int num, int gen)
+static fz_filter *
+pdf_buildfilter(pdf_xref *xref, fz_obj *stmobj, int num, int gen)
 {
-	fz_error error;
 	fz_filter *base, *pipe, *tmp;
 	fz_obj *filters;
 	fz_obj *params;
@@ -365,48 +285,26 @@ pdf_buildfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int num, in
 	filters = fz_dictgetsa(stmobj, "Filter", "F");
 	params = fz_dictgetsa(stmobj, "DecodeParms", "DP");
 
-	error = buildrawfilter(&base, xref, stmobj, num, gen);
-	if (error)
-		return fz_rethrow(error, "cannot create raw filter chain");
+	base = buildrawfilter(xref, stmobj, num, gen);
 
 	if (filters)
 	{
 		if (fz_isname(filters))
 		{
-			error = buildonefilter(&tmp, xref, filters, params, num, gen);
-			if (error)
-			{
-				fz_dropfilter(base);
-				return fz_rethrow(error, "cannot create filter");
-			}
-
-			error = fz_newpipeline(&pipe, base, tmp);
-			if (error)
-			{
-				fz_dropfilter(base);
-				fz_dropfilter(tmp);
-				return fz_rethrow(error, "cannot create filter pipeline");
-			}
-
+			tmp = buildonefilter(xref, filters, params, num, gen);
+			pipe = fz_newpipeline(base, tmp);
 			fz_dropfilter(base);
 			fz_dropfilter(tmp);
+			return pipe;
 		}
 		else
 		{
 			/* The pipeline chain takes ownership of base */
-			error = buildfilterchain(&pipe, xref, base, filters, params, num, gen);
-			if (error)
-				return fz_rethrow(error, "cannot create filter chain");
+			return buildfilterchain(xref, base, filters, params, num, gen);
 		}
-
-		*filterp = pipe;
-	}
-	else
-	{
-		*filterp = base;
 	}
 
-	return fz_okay;
+	return base;
 }
 
 /*
@@ -431,24 +329,14 @@ pdf_openrawstream(fz_stream **stmp, pdf_xref *xref, int num, int gen)
 
 	if (x->stmofs)
 	{
-		error = buildrawfilter(&filter, xref, x->obj, num, gen);
-		if (error)
-			return fz_rethrow(error, "cannot create raw filter");
-
+		filter = buildrawfilter(xref, x->obj, num, gen);
+	
 		error = fz_seek(xref->file, x->stmofs, 0);
 		if (error)
-		{
-			fz_dropfilter(filter);
 			return fz_rethrow(error, "cannot seek to stream");
-		}
-
-		error = fz_openrfilter(stmp, filter, xref->file);
 
+		*stmp = fz_openrfilter(filter, xref->file);
 		fz_dropfilter(filter);
-
-		if (error)
-			return fz_rethrow(error, "cannot open filter stream");
-
 		return fz_okay;
 	}
 
@@ -478,22 +366,14 @@ pdf_openstream(fz_stream **stmp, pdf_xref *xref, int num, int gen)
 
 	if (x->stmofs)
 	{
-		error = pdf_buildfilter(&filter, xref, x->obj, num, gen);
-		if (error)
-			return fz_rethrow(error, "cannot create filter");
+		filter = pdf_buildfilter(xref, x->obj, num, gen);
 
 		error = fz_seek(xref->file, x->stmofs, 0);
 		if (error)
-		{
-			fz_dropfilter(filter);
 			return fz_rethrow(error, "cannot seek to stream");
-		}
 
-		error = fz_openrfilter(stmp, filter, xref->file);
+		*stmp = fz_openrfilter(filter, xref->file);
 		fz_dropfilter(filter);
-		if (error)
-			return fz_rethrow(error, "cannot open filter stream");
-
 		return fz_okay;
 	}
 
@@ -513,10 +393,8 @@ pdf_loadrawstream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
 	if (error)
 		return fz_rethrow(error, "cannot open raw stream (%d %d R)", num, gen);
 
-	error = fz_readall(bufp, stm, 0);
+	*bufp = fz_readall(stm, 0); // TODO extract io errors
 	fz_dropstream(stm);
-	if (error)
-		return fz_rethrow(error, "cannot load stream into buffer (%d %d R)", num, gen);
 	return fz_okay;
 }
 
@@ -533,10 +411,8 @@ pdf_loadstream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
 	if (error)
 		return fz_rethrow(error, "cannot open stream (%d %d R)", num, gen);
 
-	error = fz_readall(bufp, stm, 0);
+	*bufp = fz_readall(stm, 0); // TODO extract io errors
 	fz_dropstream(stm);
-	if (error)
-		return fz_rethrow(error, "cannot load stream into buffer (%d %d R)", num, gen);
 	return fz_okay;
 }