Rename to tde-ebook-reader

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 209 insertions, 0 deletions

diff --git a/reader/src/formats/pdb/PalmDocStream.cpp b/reader/src/formats/pdb/PalmDocStream.cpp
new file mode 100644
index 0000000..e699d47
--- /dev/null
+++ b/reader/src/formats/pdb/PalmDocStream.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2004-2012 Geometer Plus <contact@geometerplus.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#include <cstring>
+#include <algorithm>
+
+#include <ZLFile.h>
+#include <ZLResource.h>
+#include <ZLZDecompressor.h>
+
+#include "PalmDocStream.h"
+#include "DocDecompressor.h"
+#include "HuffDecompressor.h"
+
+PalmDocStream::PalmDocStream(const ZLFile &file) : PalmDocLikeStream(file) {
+}
+
+PalmDocStream::~PalmDocStream() {
+	close();
+}
+
+bool PalmDocStream::processRecord() {
+	const std::size_t currentOffset = recordOffset(myRecordIndex);
+	if (currentOffset < myBase->offset()) {
+	    return false;
+	}
+	myBase->seek(currentOffset, true);
+	const std::size_t nextOffset = recordOffset(myRecordIndex + 1);
+	if (nextOffset < currentOffset) {
+	    return false;
+	}
+	const unsigned short recordSize = nextOffset - currentOffset;
+	switch(myCompressionVersion) {
+		case 17480://'DH'	// HuffCDic compression
+			myBufferLength = myHuffDecompressorPtr->decompress(*myBase, myBuffer, recordSize, myMaxRecordSize);
+			//if (myHuffDecompressorPtr->error()) {
+			//	myErrorCode = ERROR_UNKNOWN;
+			//} 
+			break;
+		case 2:				// PalmDoc compression
+			myBufferLength = DocDecompressor().decompress(*myBase, myBuffer, recordSize, myMaxRecordSize);
+			break;
+		case 1:				// No compression
+			myBufferLength = myBase->read(myBuffer, std::min(recordSize, myMaxRecordSize));
+			break;
+	}
+	myBufferOffset = 0;
+	return true;
+}
+
+bool PalmDocStream::processZeroRecord() {
+	// Uses with offset presetting to zero record offset value
+	PdbUtil::readUnsignedShort(*myBase, myCompressionVersion); // myBase offset: ^ + 2
+	switch (myCompressionVersion) {
+		case 1:
+		case 2:
+		case 17480:
+			break;
+		default:
+			myErrorCode = ERROR_COMPRESSION;
+			return false;
+	}	
+	myBase->seek(2, false);									// myBase offset: ^ + 4
+	PdbUtil::readUnsignedLongBE(*myBase, myTextLength); 	// myBase offset: ^ + 8	
+	PdbUtil::readUnsignedShort(*myBase, myTextRecordNumber); 	// myBase offset: ^ + 10
+
+	unsigned short endSectionIndex = header().Offsets.size();
+	myMaxRecordIndex = std::min(myTextRecordNumber, (unsigned short)(endSectionIndex - 1));
+	//TODO Insert in this point error message about uncompatible records and numRecords from Header
+	
+	PdbUtil::readUnsignedShort(*myBase, myMaxRecordSize); 	// myBase offset: ^ + 12
+	if (myMaxRecordSize == 0) {
+		myErrorCode = ERROR_UNKNOWN;
+		return false;
+	}
+
+	/*
+	std::cerr << "PalmDocStream::processRecord0():\n";
+	std::cerr << "PDB header indentificator            : " << header().Id << "\n";
+	std::cerr << "PDB file system: sizeof opened       : " << myBaseSize << "\n";
+	std::cerr << "PDB header/record[0] max index       : " << myMaxRecordIndex << "\n";
+	std::cerr << "PDB record[0][0..2] compression      : " << myCompressionVersion << "\n";
+	std::cerr << "PDB record[0][2..4] spare            : " << mySpare << "\n";
+	std::cerr << "PDB record[0][4..8] text length      : " << myTextLength << "\n";
+	std::cerr << "PDB record[0][8..10] text records    : " << myTextRecords << "\n";
+	std::cerr << "PDB record[0][10..12] max record size: " << myMaxRecordSize << "\n";
+	*/
+
+	if (header().Id == "BOOKMOBI") {
+		unsigned short encrypted = 0;
+		PdbUtil::readUnsignedShort(*myBase, encrypted); 		// myBase offset: ^ + 14
+		if (encrypted) { 										//Always = 2, if encrypted 
+			myErrorCode = ERROR_ENCRYPTION;
+			return false;
+		}
+	} else {
+		myBase->seek(2, false);
+	}
+
+
+	if (myCompressionVersion == 17480) {
+		unsigned long mobiHeaderLength;
+		unsigned long huffSectionIndex;
+		unsigned long huffSectionNumber;
+		unsigned short extraFlags;
+		unsigned long initialOffset = header().Offsets[0];				// myBase offset: ^ 
+		
+		myBase->seek(6, false); 										// myBase offset: ^ + 20
+		PdbUtil::readUnsignedLongBE(*myBase, mobiHeaderLength); 		// myBase offset: ^ + 24
+
+		myBase->seek(0x70 - 24, false); 								// myBase offset: ^ + 102 (0x70)
+		PdbUtil::readUnsignedLongBE(*myBase, huffSectionIndex); 		// myBase offset: ^ + 106 (0x74)
+		PdbUtil::readUnsignedLongBE(*myBase, huffSectionNumber);		// myBase offset: ^ + 110 (0x78)
+
+		if (mobiHeaderLength >= 244) {
+			myBase->seek(0xF2 - 0x78, false); 							// myBase offset: ^ + 242 (0xF2) 
+			PdbUtil::readUnsignedShort(*myBase, extraFlags);			// myBase offset: ^ + 244 (0xF4)
+		} else {
+			extraFlags = 0;
+		}
+		/*
+		std::cerr << "mobi header length: " <<  mobiHeaderLength << "\n";
+		std::cerr << "Huff's start record  : " << huffSectionIndex << " from " << endSectionIndex - 1 << "\n";
+		std::cerr << "Huff's records number: " << huffSectionNumber << "\n";
+		std::cerr << "Huff's extraFlags    : " << extraFlags << "\n";
+		*/
+		const unsigned long endHuffSectionIndex = huffSectionIndex + huffSectionNumber; 
+		if (endHuffSectionIndex > endSectionIndex || huffSectionNumber <= 1) {
+			myErrorCode = ERROR_COMPRESSION;
+			return false;
+		}
+		const unsigned long endHuffDataOffset = recordOffset(endHuffSectionIndex);
+		std::vector<unsigned long>::const_iterator beginHuffSectionOffsetIt = header().Offsets.begin() + huffSectionIndex;
+		// point to first Huff section
+		std::vector<unsigned long>::const_iterator endHuffSectionOffsetIt =	header().Offsets.begin() + endHuffSectionIndex;
+		// point behind last Huff section 
+
+		
+		myHuffDecompressorPtr = new HuffDecompressor(*myBase, beginHuffSectionOffsetIt, endHuffSectionOffsetIt, endHuffDataOffset, extraFlags);
+		myBase->seek(initialOffset, true);									// myBase offset: ^ + 14
+	}
+	return true;
+}
+
+bool PalmDocStream::hasExtraSections() const {
+	return myMaxRecordIndex < header().Offsets.size() - 1;
+}
+
+std::pair<int,int> PalmDocStream::imageLocation(const PdbHeader &header, int index) const {
+	index += myMaxRecordIndex + 1;
+	int recordNumber = header.Offsets.size();
+	if (index > recordNumber - 1) {
+		return std::make_pair(-1, -1);
+	} else {
+		int start = header.Offsets[index];
+		int end = (index < recordNumber - 1) ?
+			header.Offsets[index + 1] : myBase->offset();
+		return std::make_pair(start, end - start);
+	}
+}
+
+int PalmDocStream::firstImageLocationIndex(const std::string &fileName) {
+	shared_ptr<ZLInputStream> fileStream = ZLFile(fileName).inputStream();
+	if (fileStream.isNull() || !fileStream->open()) {
+		return -1;
+	}
+
+	bool found = false;
+	int index = 0;
+	char bu[5] = { 0 };
+	std::pair<int,int> firstImageLocation = imageLocation(header(), 0);
+	fileStream->seek(firstImageLocation.first, false);
+	while ((firstImageLocation.first > 0) && (firstImageLocation.second > 0)) {
+		if (firstImageLocation.second > 4) {
+			fileStream->read(bu, 4);
+			static const char jpegStart[2] = { (char)0xFF, (char)0xd8 };
+			if (std::strncmp(bu, "BM", 2) == 0 ||
+					std::strncmp(bu, "GIF8", 4) == 0 ||
+					std::strncmp(bu, jpegStart, 2) == 0) {
+				found = true;
+				break;
+			}
+			fileStream->seek(firstImageLocation.second - 4, false);
+		} else {
+			fileStream->seek(firstImageLocation.second, false);
+		}
+		index++;
+		firstImageLocation = imageLocation(header(), index);
+	}
+
+	fileStream->close();
+	return found ? index : -1;
+}