muhammara 2.1.0 → 2.2.0

package/src/deps/PDFWriter/InputLZWDecodeStream.cpp

@@ -0,0 +1,208 @@
+/*
+   Source File : InputLZWDecodeStream.cpp
+
+
+   Copyright 2011 Gal Kahana PDFWriter
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+   
+*/
+#include "InputLZWDecodeStream.h"
+
+#include "Trace.h"
+#include "zlib.h"
+
+
+InputLZWDecodeStream::InputLZWDecodeStream(int early)
+{
+	mSourceStream = NULL;
+	mCurrentlyEncoding = false;
+	mEarly = early;
+	inputBuf = 0;
+}
+
+InputLZWDecodeStream::~InputLZWDecodeStream(void)
+{
+	if(mCurrentlyEncoding)
+		FinalizeEncoding();
+	if(mSourceStream)
+		delete mSourceStream;	
+}
+
+void InputLZWDecodeStream::FinalizeEncoding()
+{	
+	mCurrentlyEncoding = false;
+}
+
+InputLZWDecodeStream::InputLZWDecodeStream(IByteReader* inSourceReader)
+{	
+	mSourceStream = NULL;
+	mCurrentlyEncoding = false;
+
+	Assign(inSourceReader);
+}
+
+void InputLZWDecodeStream::Assign(IByteReader* inSourceReader)
+{
+	mSourceStream = inSourceReader;
+	if(mSourceStream)
+		StartEncoding();
+}
+
+void InputLZWDecodeStream::StartEncoding()
+{	
+    mCurrentlyEncoding = true;
+
+	inputBits = 0;
+	ClearTable();
+}
+
+IOBasicTypes::LongBufferSizeType InputLZWDecodeStream::Read(IOBasicTypes::Byte* inBuffer, IOBasicTypes::LongBufferSizeType inBufferSize)
+{
+	if (mCurrentlyEncoding)
+	{
+		if (seqIndex >= seqLength)
+		{
+			if (!ProcessNextCode())
+				return 0;
+		}
+		memcpy(inBuffer, &seqBuf[seqIndex], 1);
+		seqIndex++;
+		return 1;		
+	}
+	return 0;
+}
+
+bool InputLZWDecodeStream::ProcessNextCode() 
+{
+	int code;
+	int nextLength;
+	int i, j;
+
+	// check for EOF
+	bool ret = false;
+	do
+	{
+		if (!mCurrentlyEncoding)
+			break;
+		// check for eod and clear-table codes
+		do
+		{
+			code = GetCode();
+			if (code == -1 || code == 257)
+			{
+				mCurrentlyEncoding = false;
+				break;
+			}
+			if (code == 256)
+			{
+				ClearTable();				
+			}
+		} while (code == 256);
+
+		if(!mCurrentlyEncoding)
+			break;		
+
+		if (nextCode >= 4097) 
+		{
+			//error(getPos(), "Bad LZW stream - expected clear-table code");
+			ClearTable();
+		}
+
+		// process the next code
+		nextLength = seqLength + 1;
+		if (code < 256) 
+		{
+			seqBuf[0] = code;
+			seqLength = 1;
+		}
+		else if (code < nextCode) 
+		{
+			seqLength = table[code].length;
+			for (i = seqLength - 1, j = code; i > 0; --i) {
+				seqBuf[i] = table[j].tail;
+				j = table[j].head;
+			}
+			seqBuf[0] = j;
+		}
+		else if (code == nextCode) 
+		{
+			seqBuf[seqLength] = newChar;
+			++seqLength;
+		}
+		else 
+		{
+			//error(getPos(), "Bad LZW stream - unexpected code");
+			mCurrentlyEncoding = false;
+			break;
+		}
+		newChar = seqBuf[0];
+		if (first) {
+			first = false;
+		}
+		else {
+			table[nextCode].length = nextLength;
+			table[nextCode].head = prevCode;
+			table[nextCode].tail = newChar;
+			++nextCode;
+			if (nextCode + mEarly == 512)
+				nextBits = 10;
+			else if (nextCode + mEarly == 1024)
+				nextBits = 11;
+			else if (nextCode + mEarly == 2048)
+				nextBits = 12;
+		}
+		prevCode = code;
+
+		// reset buffer
+		seqIndex = 0;
+
+		ret = true;
+
+	} while (false);
+	return ret;
+}
+
+
+void InputLZWDecodeStream::ClearTable() {
+	nextCode = 258;
+	nextBits = 9;
+	seqIndex = seqLength = 0;
+	first = true;
+}
+
+int InputLZWDecodeStream::GetCode() {
+	int c;
+	int code;
+
+	IOBasicTypes::Byte buffer;
+	while (inputBits < nextBits) 
+	{
+		mSourceStream->Read(&buffer, 1);
+		c = buffer;
+
+		if (c == -1) return -1;
+		inputBuf = (inputBuf << 8) | (c & 0xff);
+		inputBits += 8;
+	}
+	code = (inputBuf >> (inputBits - nextBits)) & ((1 << nextBits) - 1);
+	inputBits -= nextBits;
+	inputBuf = inputBuf & ((1 << inputBits) - 1); // avoid overflow by limiting to the bits its supposed to use 
+	return code;
+}
+
+bool InputLZWDecodeStream::NotEnded()
+{
+	return mCurrentlyEncoding;
+}

package/src/deps/PDFWriter/InputLZWDecodeStream.h

@@ -0,0 +1,77 @@
+/*
+   Source File : InputLZWDecodeStream.h
+
+
+   Copyright 2011 Gal Kahana PDFWriter
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+   
+*/
+#pragma once
+
+#include "EStatusCode.h"
+#include "IByteReader.h"
+
+class InputLZWDecodeStream : public IByteReader
+{
+public:
+	InputLZWDecodeStream(int early);
+
+	// Note that assigning passes ownership on the stream, use Assign(NULL) to remove ownership
+	InputLZWDecodeStream(IByteReader* inSourceReader);
+	virtual ~InputLZWDecodeStream(void);
+
+	// Assigning passes ownership of the input stream to the decoder stream. 
+	// if you don't care for that, then after finishing with the decode, Assign(NULL).
+	void Assign(IByteReader* inSourceReader);
+
+	// IByteReader implementation. note that "inBufferSize" determines how many
+	// bytes will be placed in the Buffer...not how many are actually read from the underlying
+	// encoded stream. got it?!
+	virtual IOBasicTypes::LongBufferSizeType Read(IOBasicTypes::Byte* inBuffer,IOBasicTypes::LongBufferSizeType inBufferSize);
+
+	virtual bool NotEnded();
+
+private:
+	
+	IByteReader* mSourceStream;
+	
+	bool mCurrentlyEncoding;
+	
+	int mEarly;			// early parameter
+	int inputBuf;		// input buffer
+	int inputBits;		// number of bits in input buffer
+
+	struct {			// decoding table
+		int length;
+		int head;
+		IOBasicTypes::Byte tail;
+	} table[4097];
+	int nextCode;			// next code to be used
+	int nextBits;			// number of bits in next code word
+	int prevCode;			// previous code used in stream
+	int newChar;			// next char to be added to table
+	IOBasicTypes::Byte		seqBuf[4097];		// buffer for current sequence
+	int seqLength;		// length of current sequence
+	int seqIndex;			// index into current sequence
+	bool first;			// first code after a table clear
+
+	bool ProcessNextCode();
+	void ClearTable();
+	int GetCode();
+
+	void FinalizeEncoding();	
+	void StartEncoding();
+
+};

package/src/deps/PDFWriter/InputStreamSkipperStream.cpp

@@ -53,7 +53,7 @@ IOBasicTypes::LongBufferSizeType InputStreamSkipperStream::Read(IOBasicTypes::By
 
 bool InputStreamSkipperStream::NotEnded()
 {
-	return mStream->NotEnded();
+	return mStream ? mStream->NotEnded() : false;
 }
 
 

package/src/deps/PDFWriter/JPEGImageHandler.h

@@ -58,14 +58,14 @@ public:
 
 	// use this for retrieving image information for JPEG (useful for deciphering JPG dimensions tags)
 	BoolAndJPEGImageInformation RetrieveImageInformation(const std::string& inJPGFilePath);
-  BoolAndJPEGImageInformation RetrieveImageInformation(IByteReaderWithPosition* inJPGStream);
+	BoolAndJPEGImageInformation RetrieveImageInformation(IByteReaderWithPosition* inJPGStream);
 
 	// DocumentContext::CreateImageXObjectFromJPGFile are equivelent
 	PDFImageXObject* CreateImageXObjectFromJPGFile(const std::string& inJPGFilePath);
 	PDFImageXObject* CreateImageXObjectFromJPGStream(IByteReaderWithPosition* inJPGStream);
 	PDFImageXObject* CreateImageXObjectFromJPGFile(const std::string& inJPGFilePath,ObjectIDType inImageXObjectID);
 	PDFImageXObject* CreateImageXObjectFromJPGStream(IByteReaderWithPosition* inJPGStream,ObjectIDType inImageXObjectID);
-
+	
 	// will return form XObject, which will include the xobject at it's size
 	PDFFormXObject* CreateFormXObjectFromJPGFile(const std::string& inJPGFilePath);
 	PDFFormXObject* CreateFormXObjectFromJPGStream(IByteReaderWithPosition* inJPGStream);

package/src/deps/PDFWriter/ObjectsContext.cpp

@@ -378,6 +378,11 @@ void ObjectsContext::SetCompressStreams(bool inCompressStreams)
 	mCompressStreams = inCompressStreams;
 }
 
+bool ObjectsContext::IsCompressingStreams()
+{
+	return mCompressStreams;
+}
+
 static const std::string scLength = "Length";
 static const std::string scStream = "stream";
 static const std::string scEndStream = "endstream";

package/src/deps/PDFWriter/ObjectsContext.h

@@ -114,6 +114,7 @@ public:
 
 	// Sets whether streams created by the objects context will be compressed (with flate) or not
 	void SetCompressStreams(bool inCompressStreams);
+	bool IsCompressingStreams();
 
 	// Create PDF stream and write it's header. note that stream are written with indirect object for Length, to allow one pass writing.
 	// inStreamDictionary can be passed in order to include stream generic information in an already written stream dictionary

package/src/deps/PDFWriter/PDFDocumentHandler.cpp

@@ -2018,9 +2018,24 @@ EStatusCode PDFDocumentHandler::WriteStreamObject(PDFStreamInput* inStream, IObj
 
 	MapIterator<PDFNameToPDFObjectMap> it(streamDictionary->GetIterator());
 	EStatusCode status = PDFHummus::eSuccess;
+	bool readingDecrypted = false;
+	IByteReader* streamReader = NULL;
+
+	/*
+	*	To support unencrypted pdf output, mostly used for debugging, (and maybe i should put a general flag there),
+	*	add ability here to copy by rewriting the streams...when possible.
+	*/
+	if(!mObjectsContext->IsCompressingStreams()) {
+		streamReader = mParser->StartReadingFromStream(inStream);
+		readingDecrypted = streamReader != NULL;
+	}	
+	if(!readingDecrypted) {
+		streamReader = mParser->StartReadingFromStreamForPlainCopying(inStream);
+	}
+	
 	while (it.MoveNext() && PDFHummus::eSuccess == status)
 	{
-		if (it.GetKey()->GetValue() != "Length") {
+		if (it.GetKey()->GetValue() != "Length" && (!readingDecrypted || it.GetKey()->GetValue() != "Filter")) {
 			status = newStreamDictionary->WriteKey(it.GetKey()->GetValue());
 			if (PDFHummus::eSuccess == status)
 				status = WriteObjectByType(it.GetValue(), eTokenSeparatorEndLine, inWritePolicy);
@@ -2033,9 +2048,10 @@ EStatusCode PDFDocumentHandler::WriteStreamObject(PDFStreamInput* inStream, IObj
 		return PDFHummus::eFailure;
 	}
 
-	PDFStream* newStream = mObjectsContext->StartUnfilteredPDFStream(newStreamDictionary);
+	PDFStream* newStream = readingDecrypted ?
+		mObjectsContext->StartPDFStream(newStreamDictionary) :
+		mObjectsContext->StartUnfilteredPDFStream(newStreamDictionary);
 	OutputStreamTraits outputTraits(newStream->GetWriteStream());
-	IByteReader* streamReader = mParser->StartReadingFromStreamForPlainCopying(inStream);
 
 	status = outputTraits.CopyToOutputStream(streamReader);
 	if (status != PDFHummus::eSuccess)

package/src/deps/PDFWriter/PDFObject.cpp

@@ -19,6 +19,7 @@
    
 */
 #include "PDFObject.h"
+#include "IDeletable.h"
 
 const char* PDFObject::scPDFObjectTypeLabel(int index) 
 {
@@ -53,9 +54,9 @@ PDFObject::PDFObject(int inType)
 
 PDFObject::~PDFObject(void)
 {
-	StringToVoidP::iterator it = mMetadata.begin();
+	StringToIDeletable::iterator it = mMetadata.begin();
 	for (; it != mMetadata.end(); ++it) {
-		delete it->second;
+		it->second->DeleteMe();
 	}
 	mMetadata.clear();
 }
@@ -65,15 +66,15 @@ PDFObject::EPDFObjectType PDFObject::GetType()
 	return mType;
 }
 
-void PDFObject::SetMetadata(const std::string& inKey, void* inValue) {
+void PDFObject::SetMetadata(const std::string& inKey, IDeletable* inValue) {
 	// delete old metadata
 	DeleteMetadata(inKey);
 
-	mMetadata.insert(StringToVoidP::value_type(inKey, inValue));
+	mMetadata.insert(StringToIDeletable::value_type(inKey, inValue));
 }
 
-void* PDFObject::GetMetadata(const std::string& inKey) {
-	StringToVoidP::iterator it = mMetadata.find(inKey);
+IDeletable* PDFObject::GetMetadata(const std::string& inKey) {
+	StringToIDeletable::iterator it = mMetadata.find(inKey);
 	
 	if (it == mMetadata.end()) 
 		return NULL;
@@ -81,19 +82,20 @@ void* PDFObject::GetMetadata(const std::string& inKey) {
 		return it->second;
 }
 
-void* PDFObject::DetachMetadata(const std::string& inKey) {
-	StringToVoidP::iterator it = mMetadata.find(inKey);
+IDeletable* PDFObject::DetachMetadata(const std::string& inKey) {
+	StringToIDeletable::iterator it = mMetadata.find(inKey);
 
 	if (it == mMetadata.end())
 		return NULL;
 	else {
-		void* result = it->second;
+		IDeletable* result = it->second;
 		mMetadata.erase(it);
 		return result;
 	}
 }
 
 void PDFObject::DeleteMetadata(const std::string& inKey) {
-	void* result = DetachMetadata(inKey);
-	delete result;
+	IDeletable* result = DetachMetadata(inKey);
+	if(result)
+		result->DeleteMe();
 }

package/src/deps/PDFWriter/PDFObject.h

@@ -25,7 +25,9 @@
 #include <string>
 #include <map>
 
-typedef std::map<std::string, void*> StringToVoidP;
+class IDeletable;
+
+typedef std::map<std::string, IDeletable*> StringToIDeletable;
 
 class PDFObject : public RefCountObject
 {
@@ -58,14 +60,14 @@ public:
 	/*
 		metadata will automatically be deleted when object is released
 	*/
-	void SetMetadata(const std::string& inKey,void* inValue); // will automatically delete old data in the same key
-	void* GetMetadata(const std::string& inKey);
+	void SetMetadata(const std::string& inKey,IDeletable* inValue); // will automatically delete old data in the same key
+	IDeletable* GetMetadata(const std::string& inKey);
 	// Detach will only remove the pointer from metadata map, Delete will also delete the inValue pointer
-	void* DetachMetadata(const std::string& inKey);
+	IDeletable* DetachMetadata(const std::string& inKey);
 	void DeleteMetadata(const std::string& inKey);
 
 
 private:
 	EPDFObjectType mType;
-	StringToVoidP mMetadata;
+	StringToIDeletable mMetadata;
 };

package/src/deps/PDFWriter/PDFObjectParser.cpp

@@ -706,4 +706,12 @@ void PDFObjectParser::SetDecryptionHelper(DecryptionHelper* inDecryptionHelper)
 void PDFObjectParser::SetParserExtender(IPDFParserExtender* inParserExtender)
 {
 	mParserExtender = inParserExtender;
+}
+
+IByteReader* PDFObjectParser::StartExternalRead() {
+	return mStream;
+}
+
+void PDFObjectParser::EndExternalRead() {
+	ResetReadState();
 }

package/src/deps/PDFWriter/PDFObjectParser.h

@@ -49,6 +49,7 @@ public:
 	// Assign the stream to read from (does not take ownership of the stream, unless told so)
 	void SetReadStream(IByteReader* inSourceStream,IReadPositionProvider* inCurrentPositionProvider,bool inOwnsStream=false);
 
+	// the important bit - get next object in content stream
 	PDFObject* ParseNewObject();
 
 	// calls this when changing underlying stream position
@@ -64,6 +65,11 @@ public:
 	// helper method for others who need to parse encoded pdf data
 	std::string DecodeHexString(const std::string inStringToDecode);
 
+	// External reading. use to temporarily get access to the internal stream, instead of reading objects with ParseNewObject.
+	// when done mark with FinishExternalReading to commence reading
+	IByteReader* StartExternalRead();
+	void EndExternalRead();
+
 private:
 	PDFParserTokenizer mTokenizer;
 	StringList mTokenBuffer;

package/src/deps/PDFWriter/PDFParser.cpp

@@ -36,6 +36,7 @@
 #include "PDFStreamInput.h"
 #include "InputLimitedStream.h"
 #include "InputFlateDecodeStream.h"
+#include "InputLZWDecodeStream.h"
 #include "InputStreamSkipperStream.h"
 #include "InputPredictorPNGOptimumStream.h"
 #include "InputPredictorTIFFSubStream.h"
@@ -1925,27 +1926,39 @@ EStatusCodeAndIByteReader PDFParser::CreateFilterForStream(IByteReader* inStream
 	do
 	{
 
-		if(inFilterName->GetValue() == "FlateDecode")
+		if(inFilterName->GetValue() == "FlateDecode" || inFilterName->GetValue() == "LZWDecode")
 		{
-			InputFlateDecodeStream* flateStream;
-			flateStream = new InputFlateDecodeStream(NULL); // assigning null, so later delete, if failure occurs won't delete the input stream
-			result = flateStream;
-
-			// check for predictor n' such
-			if(!inDecodeParams)
+			if (inFilterName->GetValue() == "FlateDecode")
 			{
-				// no predictor, stop here
+				InputFlateDecodeStream* flateStream;
+				flateStream = new InputFlateDecodeStream(NULL); // assigning null, so later delete, if failure occurs won't delete the input stream
 				flateStream->Assign(inStream);
-				break;
+				result = flateStream;
+			}
+			else if (inFilterName->GetValue() == "LZWDecode")
+			{
+				InputLZWDecodeStream* lzwStream;
+				int early = 1;
+				if (inDecodeParams)
+				{
+					PDFObjectCastPtr<PDFInteger> earlyObj(QueryDictionaryObject(inDecodeParams, "EarlyChange"));
+					early = earlyObj->GetValue();
+				}
+				lzwStream = new InputLZWDecodeStream(early);
+				lzwStream->Assign(inStream);
+				result = lzwStream;
 			}
 
+			// check for predictor n' such
+			if (!inDecodeParams)
+				// no predictor, stop here
+				break;			
+
 			// read predictor, and apply the relevant predictor function
 			PDFObjectCastPtr<PDFInteger> predictor(QueryDictionaryObject(inDecodeParams,"Predictor"));
 
 			if(!predictor || predictor->GetValue() == 1)
 			{
-				// no predictor or default, stop here
-				flateStream->Assign(inStream);
 				break;
 			}
 
@@ -1994,7 +2007,6 @@ EStatusCodeAndIByteReader PDFParser::CreateFilterForStream(IByteReader* inStream
 					break;
 				}
 			}
-			flateStream->Assign(inStream);
 		}
 		else if (inFilterName->GetValue() == "ASCIIHexDecode")
 		{
@@ -2028,7 +2040,7 @@ EStatusCodeAndIByteReader PDFParser::CreateFilterForStream(IByteReader* inStream
 		}
 		else
 		{
-			TRACE_LOG("PDFParser::CreateFilterForStream, supporting only flate decode and ascii 85 decode, failing");
+			TRACE_LOG("PDFParser::CreateFilterForStream, supporting only flate decode, lzw, dct, crypt and ascii 85+hex decode, failing");
 			status = PDFHummus::eFailure;
 			break;
 		}