feat: allow asking for using xref streams, which opens the option to build very large files

galkahana · galkahana · commit de970d41121e · 2024-12-08T22:05:52.000+02:00
diff --git a/PDFWriter/DocumentContext.cpp b/PDFWriter/DocumentContext.cpp
@@ -60,6 +60,7 @@ DocumentContext::DocumentContext()
 	mObjectsContext = NULL;
 	mParserExtender = NULL;
     mModifiedDocumentIDExists = false;
+	SetWriteXrefAsXrefStream(false);
 }
 
 DocumentContext::~DocumentContext(void)
@@ -80,12 +81,26 @@ void DocumentContext::SetObjectsContext(ObjectsContext* inObjectsContext)
 	mPNGImageHandler.SetOperationsContexts(this, mObjectsContext);
 #endif
 	mExtGStateRegistry.SetObjectsContext(mObjectsContext);
+	SetupXrefMaxWritePositionValidation();
+}
+
+void DocumentContext::SetupXrefMaxWritePositionValidation()
+{
+	// Validating Max Xref position to be 10 digits long is only relevant for regular xref writing.
+	// Cancel validation if xref stream is used instead.
+	if(mObjectsContext)
+		mObjectsContext->GetInDirectObjectsRegistry().SetShouldValidateMaxWritePositionForXref(!mWriteXrefAsXrefStream);
 }
 
 void DocumentContext::SetEmbedFonts(bool inEmbedFonts) {
 	mUsedFontsRepository.SetEmbedFonts(inEmbedFonts);
 }
 
+void DocumentContext::SetWriteXrefAsXrefStream(bool inWriteXrefAsXrefStream) {
+	mWriteXrefAsXrefStream = inWriteXrefAsXrefStream;
+	SetupXrefMaxWritePositionValidation();
+}
+
 void DocumentContext::SetOutputFileInformation(OutputFile* inOutputFile)
 {
 	// just save the output file path for the ID generation in the end
@@ -222,13 +237,20 @@ EStatusCode	DocumentContext::FinalizeNewPDF()
 		if (status != eSuccess)
 			break;
 
-		status = mObjectsContext->WriteXrefTable(xrefTablePosition);
-		if(status != eSuccess)
-			break;
+		if(mWriteXrefAsXrefStream) {
+			status = WriteXrefStream(xrefTablePosition);
+            if(status != eSuccess)
+                break;			
+		} else {
+			status = mObjectsContext->WriteXrefTable(xrefTablePosition);
+			if(status != eSuccess)
+				break;
 
-		status = WriteTrailerDictionary();
-		if(status != eSuccess)
-			break;
+			status = WriteTrailerDictionary();
+			if(status != eSuccess)
+				break;
+
+		}
 
 		WriteXrefReference(xrefTablePosition);
 		WriteFinalEOF();
@@ -2343,8 +2365,31 @@ void DocumentContext::UnRegisterCopyingContext(PDFDocumentCopyingContext* inCopy
 	mCopyingContexts.erase(inCopyingContext);
 }
 
+
+bool DocumentContext::RequiresXrefStream(PDFParser* inModifiedFileParser)
+{
+    // modification requires xref stream if the original document uses one...so just ask trailer
+    if(!inModifiedFileParser->GetTrailer())
+        return false;
+
+    PDFObjectCastPtr<PDFName> typeObject = inModifiedFileParser->GetTrailer()->QueryDirectObject("Type");
+
+    if(!typeObject)
+        return false;
+
+    return typeObject->GetValue() == "XRef";
+
+
+}
+
+
 EStatusCode DocumentContext::SetupModifiedFile(PDFParser* inModifiedFileParser)
 {
+	// determine if file requires xref stream, in which case set it up
+	if(RequiresXrefStream(inModifiedFileParser)) {
+		SetWriteXrefAsXrefStream(true); // it may already have been setup to be true earlier by the users request, but if not, and this file requires it, set it up now
+	}		
+
     // setup trailer and save original document ID
 
     if(!inModifiedFileParser->GetTrailer())
@@ -2514,9 +2559,11 @@ EStatusCode	DocumentContext::FinalizeModifiedPDF(PDFParser* inModifiedFileParser
 		status = CopyEncryptionDictionary(inModifiedFileParser);
         if(status != eSuccess)
             break;
-        if(RequiresXrefStream(inModifiedFileParser))
+        if(mWriteXrefAsXrefStream)
         {
             status = WriteXrefStream(xrefTablePosition);
+            if(status != eSuccess)
+                break;			
         }
         else
         {
@@ -2781,21 +2828,6 @@ EStatusCode DocumentContext::CopyEncryptionDictionary(PDFParser* inModifiedFileP
 	return eSuccess;
 }
 
-bool DocumentContext::RequiresXrefStream(PDFParser* inModifiedFileParser)
-{
-    // modification requires xref stream if the original document uses one...so just ask trailer
-    if(!inModifiedFileParser->GetTrailer())
-        return false;
-
-    PDFObjectCastPtr<PDFName> typeObject = inModifiedFileParser->GetTrailer()->QueryDirectObject("Type");
-
-    if(!typeObject)
-        return false;
-
-    return typeObject->GetValue() == "XRef";
-
-
-}
 
 EStatusCode DocumentContext::WriteXrefStream(LongFilePositionType& outXrefPosition)
 {
diff --git a/PDFWriter/DocumentContext.h b/PDFWriter/DocumentContext.h
@@ -119,6 +119,7 @@ namespace PDFHummus
 		void SetObjectsContext(ObjectsContext* inObjectsContext);
 		void SetOutputFileInformation(OutputFile* inOutputFile);
 		void SetEmbedFonts(bool inEmbedFonts);
+		void SetWriteXrefAsXrefStream(bool inWriteXrefAsXrefStream);
 		PDFHummus::EStatusCode	WriteHeader(EPDFVersion inPDFVersion);
 		PDFHummus::EStatusCode	FinalizeNewPDF();
         PDFHummus::EStatusCode	FinalizeModifiedPDF(PDFParser* inModifiedFileParser,EPDFVersion inModifiedPDFVersion);
@@ -413,6 +414,7 @@ namespace PDFHummus
 	    StringAndULongPairToHummusImageInformationMap mImagesInformation;
 		EncryptionHelper mEncryptionHelper;
 		ExtGStateRegistry mExtGStateRegistry;
+		bool mWriteXrefAsXrefStream;
 
 		void WriteHeaderComment(EPDFVersion inPDFVersion);
 		void Write4BinaryBytes();
@@ -461,5 +463,6 @@ namespace PDFHummus
 		bool RequiresXrefStream(PDFParser* inModifiedFileParser);
         PDFHummus::EStatusCode WriteXrefStream(LongFilePositionType& outXrefPosition);
 		HummusImageInformation& GetImageInformationStructFor(const std::string& inImageFile,unsigned long inImageIndex);
+		void SetupXrefMaxWritePositionValidation();
 	};
 }
diff --git a/PDFWriter/IndirectObjectsReferenceRegistry.cpp b/PDFWriter/IndirectObjectsReferenceRegistry.cpp
@@ -37,6 +37,7 @@ using namespace PDFHummus;
 IndirectObjectsReferenceRegistry::IndirectObjectsReferenceRegistry(void)
 {
     SetupInitialFreeObject();
+	SetShouldValidateMaxWritePositionForXref(true);
 }
 
 void IndirectObjectsReferenceRegistry::SetupInitialFreeObject()
@@ -51,6 +52,11 @@ void IndirectObjectsReferenceRegistry::SetupInitialFreeObject()
 	mObjectsWritesRegistry.push_back(singleFreeObjectInformation);
 }
 
+void IndirectObjectsReferenceRegistry::SetShouldValidateMaxWritePositionForXref(bool inShouldValidate)
+{
+	mShouldValidateMaxWritePositionForXref = inShouldValidate;
+}
+
 IndirectObjectsReferenceRegistry::~IndirectObjectsReferenceRegistry(void)
 {
 }
@@ -70,6 +76,20 @@ ObjectIDType IndirectObjectsReferenceRegistry::AllocateNewObjectID()
 	return newObjectID;
 }
 
+EStatusCode IndirectObjectsReferenceRegistry::MaybeValidateMaxWritePositionForXref(LongFilePositionType inWritePosition)
+{
+	if(!mShouldValidateMaxWritePositionForXref)
+		return PDFHummus::eSuccess;
+
+	if(inWritePosition > 9999999999LL) // if write position is larger than what can be represented by 10 digits, xref write will fail
+	{
+		TRACE_LOG1("IndirectObjectsReferenceRegistry::MaybeValidateMaxWritePositionForXref, Write position out of bounds. Trying to write an object at position that cannot be represented in Xref = %lld. probably means file got too long",inWritePosition);
+		return PDFHummus::eFailure;
+	}
+
+	return PDFHummus::eSuccess;	
+}
+
 
 EStatusCode IndirectObjectsReferenceRegistry::MarkObjectAsWritten(ObjectIDType inObjectID,LongFilePositionType inWritePosition)
 {
@@ -86,9 +106,8 @@ EStatusCode IndirectObjectsReferenceRegistry::MarkObjectAsWritten(ObjectIDType i
 		return PDFHummus::eFailure; // trying to mark as written an object that was already marked as such in the past. probably a mistake [till we have revisions]
 	}
 
-	if(inWritePosition > 9999999999LL) // if write position is larger than what can be represented by 10 digits, xref write will fail
+	if(MaybeValidateMaxWritePositionForXref(inWritePosition) != PDFHummus::eSuccess) // if write position is larger than what can be represented by 10 digits, xref write will fail
 	{
-		TRACE_LOG1("IndirectObjectsReferenceRegistry::MarkObjectAsWritten, Write position out of bounds. Trying to write an object at position that cannot be represented in Xref = %lld. probably means file got too long",inWritePosition);
 		return PDFHummus::eFailure;
 	}
 
@@ -155,12 +174,10 @@ PDFHummus::EStatusCode IndirectObjectsReferenceRegistry::MarkObjectAsUpdated(Obj
 		return PDFHummus::eFailure; 
 	}
 
-	if(inNewWritePosition > 9999999999LL) // if write position is larger than what can be represented by 10 digits, xref write will fail
+	if(MaybeValidateMaxWritePositionForXref(inNewWritePosition) != PDFHummus::eSuccess) // if write position is larger than what can be represented by 10 digits, xref write will fail
 	{
-		TRACE_LOG1("IndirectObjectsReferenceRegistry::MarkObjectAsUpdated, Write position out of bounds. Trying to write an object at position that cannot be represented in Xref = %lld. probably means file got too long",inNewWritePosition);
 		return PDFHummus::eFailure;
-	}
-
+	}	
     
     mObjectsWritesRegistry[inObjectID].mIsDirty = true;
     mObjectsWritesRegistry[inObjectID].mWritePosition = inNewWritePosition;
diff --git a/PDFWriter/IndirectObjectsReferenceRegistry.h b/PDFWriter/IndirectObjectsReferenceRegistry.h
@@ -89,12 +89,16 @@ class IndirectObjectsReferenceRegistry
 	void Reset();
  
     void SetupXrefFromModifiedFile(PDFParser* inModifiedFileParser);
+
+	void SetShouldValidateMaxWritePositionForXref(bool inShouldValidateMaxWritePositionForXref);
     
 private:
 	ObjectWriteInformationVector mObjectsWritesRegistry;
+	bool mShouldValidateMaxWritePositionForXref;
     
     void SetupInitialFreeObject();
     void AppendExistingItem(ObjectWriteInformation::EObjectReferenceType inObjectReferenceType,
                             unsigned long inGenerationNumber,
                             LongFilePositionType inWritePosition);
+	PDFHummus::EStatusCode MaybeValidateMaxWritePositionForXref(LongFilePositionType inWritePosition);
 };
diff --git a/PDFWriter/PDFWriter.cpp b/PDFWriter/PDFWriter.cpp
@@ -56,8 +56,9 @@ PDFWriter::~PDFWriter(void)
 {
 }
 
-EPDFVersion thisOrDefaultVersion(EPDFVersion inPDFVersion) {
-	return ePDFVersionUndefined == inPDFVersion ? ePDFVersion14 : inPDFVersion;
+EPDFVersion thisOrDefaultVersion(EPDFVersion inPDFVersion, bool inWriteXrefAsXrefStream) {
+	// if version is undefined, return 1.4 if xref stream is not used, 1.5 if it is (As this would be the lower version it's supported in)
+	return ePDFVersionUndefined == inPDFVersion ? (inWriteXrefAsXrefStream ? ePDFVersion15: ePDFVersion14) : inPDFVersion;
 }
 
 EStatusCode PDFWriter::StartPDF(
@@ -66,6 +67,7 @@ EStatusCode PDFWriter::StartPDF(
 							const LogConfiguration& inLogConfiguration,
 							const PDFCreationSettings& inPDFCreationSettings)
 {
+	EPDFVersion pdfVersion = thisOrDefaultVersion(inPDFVersion, inPDFCreationSettings.WriteXrefAsXrefStream);
 	SetupLog(inLogConfiguration);
 	SetupCreationSettings(inPDFCreationSettings);
 
@@ -77,7 +79,7 @@ EStatusCode PDFWriter::StartPDF(
 	mDocumentContext.SetOutputFileInformation(&mOutputFile);
 
 	if (inPDFCreationSettings.DocumentEncryptionOptions.ShouldEncrypt) {
-		mDocumentContext.SetupEncryption(inPDFCreationSettings.DocumentEncryptionOptions, thisOrDefaultVersion(inPDFVersion));
+		mDocumentContext.SetupEncryption(inPDFCreationSettings.DocumentEncryptionOptions, pdfVersion);
 		if (!mDocumentContext.SupportsEncryption()) {
 			mOutputFile.CloseFile(); // close the file, to keep things clean
 			return eFailure;
@@ -86,7 +88,7 @@ EStatusCode PDFWriter::StartPDF(
 
 	mIsModified = false;
 
-	return mDocumentContext.WriteHeader(thisOrDefaultVersion(inPDFVersion));
+	return mDocumentContext.WriteHeader(pdfVersion);
 }
 
 EStatusCode PDFWriter::EndPDF()
@@ -174,6 +176,7 @@ void PDFWriter::SetupCreationSettings(const PDFCreationSettings& inPDFCreationSe
 {
 	mObjectsContext.SetCompressStreams(inPDFCreationSettings.CompressStreams);
 	mDocumentContext.SetEmbedFonts(inPDFCreationSettings.EmbedFonts);
+	mDocumentContext.SetWriteXrefAsXrefStream(inPDFCreationSettings.WriteXrefAsXrefStream);
 }
 
 void PDFWriter::ReleaseLog()
@@ -555,18 +558,19 @@ EStatusCode PDFWriter::StartPDFForStream(IByteWriterWithPosition* inOutputStream
 										 const LogConfiguration& inLogConfiguration,
 										 const PDFCreationSettings& inPDFCreationSettings)
 {
+	EPDFVersion pdfVersion = thisOrDefaultVersion(inPDFVersion, inPDFCreationSettings.WriteXrefAsXrefStream);
 	SetupLog(inLogConfiguration);
 	SetupCreationSettings(inPDFCreationSettings);
 	if (inPDFCreationSettings.DocumentEncryptionOptions.ShouldEncrypt) {
-		mDocumentContext.SetupEncryption(inPDFCreationSettings.DocumentEncryptionOptions, thisOrDefaultVersion(inPDFVersion));
+		mDocumentContext.SetupEncryption(inPDFCreationSettings.DocumentEncryptionOptions, pdfVersion);
 		if (!mDocumentContext.SupportsEncryption())
 			return eFailure;
 	}
 
 	mObjectsContext.SetOutputStream(inOutputStream);
     mIsModified = false;
 
-	return mDocumentContext.WriteHeader(thisOrDefaultVersion(inPDFVersion));
+	return mDocumentContext.WriteHeader(pdfVersion);
 }
 EStatusCode PDFWriter::EndPDFForStream()
 {
@@ -691,7 +695,7 @@ EStatusCode PDFWriter::ModifyPDF(const std::string& inModifiedFile,
 
         // do setup for modification
         mIsModified = true;
-        status = SetupStateFromModifiedFile(inModifiedFile, thisOrDefaultVersion(inPDFVersion), inPDFCreationSettings);
+        status = SetupStateFromModifiedFile(inModifiedFile, inPDFVersion, inPDFCreationSettings);
     }
     while (false);
 
@@ -724,13 +728,14 @@ EStatusCode PDFWriter::ModifyPDFForStream(
     
     mIsModified = true;
 
-    return SetupStateFromModifiedStream(inModifiedSourceStream, thisOrDefaultVersion(inPDFVersion), inPDFCreationSettings);
+    return SetupStateFromModifiedStream(inModifiedSourceStream, inPDFVersion, inPDFCreationSettings);
 }
 
 EStatusCode PDFWriter::SetupStateFromModifiedStream(IByteReaderWithPosition* inModifiedSourceStream,
                                                     EPDFVersion inPDFVersion,
 													const PDFCreationSettings& inPDFCreationSettings)
 {
+	EPDFVersion pdfVersion = thisOrDefaultVersion(inPDFVersion, inPDFCreationSettings.WriteXrefAsXrefStream);
     EStatusCode status;
 	PDFParsingOptions parsingOptions;
 
@@ -761,7 +766,7 @@ EStatusCode PDFWriter::SetupStateFromModifiedStream(IByteReaderWithPosition* inM
 			}
 		}
 
-        mModifiedFileVersion = thisOrDefaultVersion(inPDFVersion);
+        mModifiedFileVersion = pdfVersion;
     }
     while (false);
 
@@ -778,7 +783,7 @@ EStatusCode PDFWriter::SetupStateFromModifiedFile(const std::string& inModifiedF
         if(status != eSuccess)
             break;
 
-        status = SetupStateFromModifiedStream(mModifiedFile.GetInputStream(), thisOrDefaultVersion(inPDFVersion), inPDFCreationSettings);
+        status = SetupStateFromModifiedStream(mModifiedFile.GetInputStream(), inPDFVersion, inPDFCreationSettings);
     }
     while(false);
 
diff --git a/PDFWriter/PDFWriter.h b/PDFWriter/PDFWriter.h
@@ -59,10 +59,16 @@ struct PDFCreationSettings
 	bool CompressStreams;
 	bool EmbedFonts;
 	EncryptionOptions DocumentEncryptionOptions;
+	bool WriteXrefAsXrefStream;
 
-	PDFCreationSettings(bool inCompressStreams, bool inEmbedFonts,EncryptionOptions inDocumentEncryptionOptions = EncryptionOptions::DefaultEncryptionOptions()):DocumentEncryptionOptions(inDocumentEncryptionOptions){
+	PDFCreationSettings(
+		bool inCompressStreams, 
+		bool inEmbedFonts,
+		EncryptionOptions inDocumentEncryptionOptions = EncryptionOptions::DefaultEncryptionOptions(), 
+		bool inWriteXrefAsXrefStream = false):DocumentEncryptionOptions(inDocumentEncryptionOptions){
 		CompressStreams = inCompressStreams;
 		EmbedFonts = inEmbedFonts;
+		WriteXrefAsXrefStream = inWriteXrefAsXrefStream;
 	}
 
 };
diff --git a/PDFWriterTesting/CMakeLists.txt b/PDFWriterTesting/CMakeLists.txt
@@ -76,6 +76,7 @@ create_test_sourcelist (Tests
   UppercaseSequanceTest.cpp
   WatermarkTest.cpp
   WatermarkWithContextOpacityTest.cpp
+  XrefStreamsTest.cpp
 )
 
 # add the testing executable
diff --git a/PDFWriterTesting/XrefStreamsTest.cpp b/PDFWriterTesting/XrefStreamsTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@ using namespace PDFHummus;`
`37`	`37`	`IndirectObjectsReferenceRegistry::IndirectObjectsReferenceRegistry(void)`
`38`	`38`	`{`
`39`	`39`	`SetupInitialFreeObject();`
	`40`	`+ SetShouldValidateMaxWritePositionForXref(true);`
`40`	`41`	`}`
`41`	`42`
`42`	`43`	`void IndirectObjectsReferenceRegistry::SetupInitialFreeObject()`
`@@ -51,6 +52,11 @@ void IndirectObjectsReferenceRegistry::SetupInitialFreeObject()`
`51`	`52`	`mObjectsWritesRegistry.push_back(singleFreeObjectInformation);`
`52`	`53`	`}`
`53`	`54`
	`55`	`+void IndirectObjectsReferenceRegistry::SetShouldValidateMaxWritePositionForXref(bool inShouldValidate)`
	`56`	`+{`
	`57`	`+ mShouldValidateMaxWritePositionForXref = inShouldValidate;`
	`58`	`+}`
	`59`	`+`
`54`	`60`	`IndirectObjectsReferenceRegistry::~IndirectObjectsReferenceRegistry(void)`
`55`	`61`	`{`
`56`	`62`	`}`
`@@ -70,6 +76,20 @@ ObjectIDType IndirectObjectsReferenceRegistry::AllocateNewObjectID()`
`70`	`76`	`return newObjectID;`
`71`	`77`	`}`
`72`	`78`
	`79`	`+EStatusCode IndirectObjectsReferenceRegistry::MaybeValidateMaxWritePositionForXref(LongFilePositionType inWritePosition)`
	`80`	`+{`
	`81`	`+ if(!mShouldValidateMaxWritePositionForXref)`
	`82`	`+ return PDFHummus::eSuccess;`
	`83`	`+`
	`84`	`+ if(inWritePosition > 9999999999LL) // if write position is larger than what can be represented by 10 digits, xref write will fail`
	`85`	`+ {`
	`86`	`+ TRACE_LOG1("IndirectObjectsReferenceRegistry::MaybeValidateMaxWritePositionForXref, Write position out of bounds. Trying to write an object at position that cannot be represented in Xref = %lld. probably means file got too long",inWritePosition);`
	`87`	`+ return PDFHummus::eFailure;`
	`88`	`+ }`
	`89`	`+`
	`90`	`+ return PDFHummus::eSuccess;`
	`91`	`+}`
	`92`	`+`
`73`	`93`
`74`	`94`	`EStatusCode IndirectObjectsReferenceRegistry::MarkObjectAsWritten(ObjectIDType inObjectID,LongFilePositionType inWritePosition)`
`75`	`95`	`{`
`@@ -86,9 +106,8 @@ EStatusCode IndirectObjectsReferenceRegistry::MarkObjectAsWritten(ObjectIDType i`
`86`	`106`	`return PDFHummus::eFailure; // trying to mark as written an object that was already marked as such in the past. probably a mistake [till we have revisions]`
`87`	`107`	`}`
`88`	`108`
`89`		`- if(inWritePosition > 9999999999LL) // if write position is larger than what can be represented by 10 digits, xref write will fail`
	`109`	`+ if(MaybeValidateMaxWritePositionForXref(inWritePosition) != PDFHummus::eSuccess) // if write position is larger than what can be represented by 10 digits, xref write will fail`
`90`	`110`	`{`
`91`		`- TRACE_LOG1("IndirectObjectsReferenceRegistry::MarkObjectAsWritten, Write position out of bounds. Trying to write an object at position that cannot be represented in Xref = %lld. probably means file got too long",inWritePosition);`
`92`	`111`	`return PDFHummus::eFailure;`
`93`	`112`	`}`
`94`	`113`
`@@ -155,12 +174,10 @@ PDFHummus::EStatusCode IndirectObjectsReferenceRegistry::MarkObjectAsUpdated(Obj`
`155`	`174`	`return PDFHummus::eFailure;`
`156`	`175`	`}`
`157`	`176`
`158`		`- if(inNewWritePosition > 9999999999LL) // if write position is larger than what can be represented by 10 digits, xref write will fail`
	`177`	`+ if(MaybeValidateMaxWritePositionForXref(inNewWritePosition) != PDFHummus::eSuccess) // if write position is larger than what can be represented by 10 digits, xref write will fail`
`159`	`178`	`{`
`160`		`- TRACE_LOG1("IndirectObjectsReferenceRegistry::MarkObjectAsUpdated, Write position out of bounds. Trying to write an object at position that cannot be represented in Xref = %lld. probably means file got too long",inNewWritePosition);`
`161`	`179`	`return PDFHummus::eFailure;`
`162`		`- }`
`163`		`-`
	`180`	`+ }`
`164`	`181`
`165`	`182`	`mObjectsWritesRegistry[inObjectID].mIsDirty = true;`
`166`	`183`	`mObjectsWritesRegistry[inObjectID].mWritePosition = inNewWritePosition;`
Original file line number	Diff line number	Diff line change
`@@ -56,8 +56,9 @@ PDFWriter::~PDFWriter(void)`
`56`	`56`	`{`
`57`	`57`	`}`
`58`	`58`
`59`		`-EPDFVersion thisOrDefaultVersion(EPDFVersion inPDFVersion) {`
`60`		`- return ePDFVersionUndefined == inPDFVersion ? ePDFVersion14 : inPDFVersion;`
	`59`	`+EPDFVersion thisOrDefaultVersion(EPDFVersion inPDFVersion, bool inWriteXrefAsXrefStream) {`
	`60`	`+ // if version is undefined, return 1.4 if xref stream is not used, 1.5 if it is (As this would be the lower version it's supported in)`
	`61`	`+ return ePDFVersionUndefined == inPDFVersion ? (inWriteXrefAsXrefStream ? ePDFVersion15: ePDFVersion14) : inPDFVersion;`
`61`	`62`	`}`
`62`	`63`
`63`	`64`	`EStatusCode PDFWriter::StartPDF(`
`@@ -66,6 +67,7 @@ EStatusCode PDFWriter::StartPDF(`
`66`	`67`	`const LogConfiguration& inLogConfiguration,`
`67`	`68`	`const PDFCreationSettings& inPDFCreationSettings)`
`68`	`69`	`{`
	`70`	`+ EPDFVersion pdfVersion = thisOrDefaultVersion(inPDFVersion, inPDFCreationSettings.WriteXrefAsXrefStream);`
`69`	`71`	`SetupLog(inLogConfiguration);`
`70`	`72`	`SetupCreationSettings(inPDFCreationSettings);`
`71`	`73`
`@@ -77,7 +79,7 @@ EStatusCode PDFWriter::StartPDF(`
`77`	`79`	`mDocumentContext.SetOutputFileInformation(&mOutputFile);`
`78`	`80`
`79`	`81`	`if (inPDFCreationSettings.DocumentEncryptionOptions.ShouldEncrypt) {`
`80`		`- mDocumentContext.SetupEncryption(inPDFCreationSettings.DocumentEncryptionOptions, thisOrDefaultVersion(inPDFVersion));`
	`82`	`+ mDocumentContext.SetupEncryption(inPDFCreationSettings.DocumentEncryptionOptions, pdfVersion);`
`81`	`83`	`if (!mDocumentContext.SupportsEncryption()) {`
`82`	`84`	`mOutputFile.CloseFile(); // close the file, to keep things clean`
`83`	`85`	`return eFailure;`
`@@ -86,7 +88,7 @@ EStatusCode PDFWriter::StartPDF(`
`86`	`88`
`87`	`89`	`mIsModified = false;`
`88`	`90`
`89`		`- return mDocumentContext.WriteHeader(thisOrDefaultVersion(inPDFVersion));`
	`91`	`+ return mDocumentContext.WriteHeader(pdfVersion);`
`90`	`92`	`}`
`91`	`93`
`92`	`94`	`EStatusCode PDFWriter::EndPDF()`
`@@ -174,6 +176,7 @@ void PDFWriter::SetupCreationSettings(const PDFCreationSettings& inPDFCreationSe`
`174`	`176`	`{`
`175`	`177`	`mObjectsContext.SetCompressStreams(inPDFCreationSettings.CompressStreams);`
`176`	`178`	`mDocumentContext.SetEmbedFonts(inPDFCreationSettings.EmbedFonts);`
	`179`	`+ mDocumentContext.SetWriteXrefAsXrefStream(inPDFCreationSettings.WriteXrefAsXrefStream);`
`177`	`180`	`}`
`178`	`181`
`179`	`182`	`void PDFWriter::ReleaseLog()`
`@@ -555,18 +558,19 @@ EStatusCode PDFWriter::StartPDFForStream(IByteWriterWithPosition* inOutputStream`
`555`	`558`	`const LogConfiguration& inLogConfiguration,`
`556`	`559`	`const PDFCreationSettings& inPDFCreationSettings)`
`557`	`560`	`{`
	`561`	`+ EPDFVersion pdfVersion = thisOrDefaultVersion(inPDFVersion, inPDFCreationSettings.WriteXrefAsXrefStream);`
`558`	`562`	`SetupLog(inLogConfiguration);`
`559`	`563`	`SetupCreationSettings(inPDFCreationSettings);`
`560`	`564`	`if (inPDFCreationSettings.DocumentEncryptionOptions.ShouldEncrypt) {`
`561`		`- mDocumentContext.SetupEncryption(inPDFCreationSettings.DocumentEncryptionOptions, thisOrDefaultVersion(inPDFVersion));`
	`565`	`+ mDocumentContext.SetupEncryption(inPDFCreationSettings.DocumentEncryptionOptions, pdfVersion);`
`562`	`566`	`if (!mDocumentContext.SupportsEncryption())`
`563`	`567`	`return eFailure;`
`564`	`568`	`}`
`565`	`569`
`566`	`570`	`mObjectsContext.SetOutputStream(inOutputStream);`
`567`	`571`	`mIsModified = false;`
`568`	`572`
`569`		`- return mDocumentContext.WriteHeader(thisOrDefaultVersion(inPDFVersion));`
	`573`	`+ return mDocumentContext.WriteHeader(pdfVersion);`
`570`	`574`	`}`
`571`	`575`	`EStatusCode PDFWriter::EndPDFForStream()`
`572`	`576`	`{`
`@@ -691,7 +695,7 @@ EStatusCode PDFWriter::ModifyPDF(const std::string& inModifiedFile,`
`691`	`695`
`692`	`696`	`// do setup for modification`
`693`	`697`	`mIsModified = true;`
`694`		`- status = SetupStateFromModifiedFile(inModifiedFile, thisOrDefaultVersion(inPDFVersion), inPDFCreationSettings);`
	`698`	`+ status = SetupStateFromModifiedFile(inModifiedFile, inPDFVersion, inPDFCreationSettings);`
`695`	`699`	`}`
`696`	`700`	`while (false);`
`697`	`701`
`@@ -724,13 +728,14 @@ EStatusCode PDFWriter::ModifyPDFForStream(`
`724`	`728`
`725`	`729`	`mIsModified = true;`
`726`	`730`
`727`		`- return SetupStateFromModifiedStream(inModifiedSourceStream, thisOrDefaultVersion(inPDFVersion), inPDFCreationSettings);`
	`731`	`+ return SetupStateFromModifiedStream(inModifiedSourceStream, inPDFVersion, inPDFCreationSettings);`
`728`	`732`	`}`
`729`	`733`
`730`	`734`	`EStatusCode PDFWriter::SetupStateFromModifiedStream(IByteReaderWithPosition* inModifiedSourceStream,`
`731`	`735`	`EPDFVersion inPDFVersion,`
`732`	`736`	`const PDFCreationSettings& inPDFCreationSettings)`
`733`	`737`	`{`
	`738`	`+ EPDFVersion pdfVersion = thisOrDefaultVersion(inPDFVersion, inPDFCreationSettings.WriteXrefAsXrefStream);`
`734`	`739`	`EStatusCode status;`
`735`	`740`	`PDFParsingOptions parsingOptions;`
`736`	`741`
`@@ -761,7 +766,7 @@ EStatusCode PDFWriter::SetupStateFromModifiedStream(IByteReaderWithPosition* inM`
`761`	`766`	`}`
`762`	`767`	`}`
`763`	`768`
`764`		`- mModifiedFileVersion = thisOrDefaultVersion(inPDFVersion);`
	`769`	`+ mModifiedFileVersion = pdfVersion;`
`765`	`770`	`}`
`766`	`771`	`while (false);`
`767`	`772`
`@@ -778,7 +783,7 @@ EStatusCode PDFWriter::SetupStateFromModifiedFile(const std::string& inModifiedF`
`778`	`783`	`if(status != eSuccess)`
`779`	`784`	`break;`
`780`	`785`
`781`		`- status = SetupStateFromModifiedStream(mModifiedFile.GetInputStream(), thisOrDefaultVersion(inPDFVersion), inPDFCreationSettings);`
	`786`	`+ status = SetupStateFromModifiedStream(mModifiedFile.GetInputStream(), inPDFVersion, inPDFCreationSettings);`
`782`	`787`	`}`
`783`	`788`	`while(false);`
`784`	`789`
Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,7 @@ create_test_sourcelist (Tests`
`76`	`76`	`UppercaseSequanceTest.cpp`
`77`	`77`	`WatermarkTest.cpp`
`78`	`78`	`WatermarkWithContextOpacityTest.cpp`
	`79`	`+ XrefStreamsTest.cpp`
`79`	`80`	`)`
`80`	`81`
`81`	`82`	`# add the testing executable`