PLT: move to separate class

Author: Aaron Boxer

src/lib/jp2/CMakeLists.txt

@@ -136,6 +136,8 @@ set(GROK_LIBRARY_SRCS
   ${CMAKE_CURRENT_SOURCE_DIR}/cache/MemManager.h
   ${CMAKE_CURRENT_SOURCE_DIR}/cache/LengthCache.h
   ${CMAKE_CURRENT_SOURCE_DIR}/cache/LengthCache.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache/PacketLengthMarkers.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache/PacketLengthMarkers.cpp
 
   ${CMAKE_CURRENT_SOURCE_DIR}/point_transform/mct.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/point_transform/mct.h

src/lib/jp2/cache/LengthCache.cpp

@@ -18,15 +18,6 @@
 
 namespace grk {
 
-// bytes available in PLT marker to store packet lengths
-// (4 bytes are reserved for (marker + marker length), and 1 byte for index)
-const uint32_t available_packet_len_bytes_per_plt = USHRT_MAX - 1 - 4;
-
-// minimum number of packet lengths that can be stored in a full
-// length PLT marker
-// (5 is maximum number of bytes for a single packet length)
-const uint32_t min_packets_per_full_plt = available_packet_len_bytes_per_plt / 5;
-
 // TLM(2) + Ltlm(2) + Ztlm(1) + Stlm(1)
 const uint32_t tlm_marker_start_bytes = 6;
 
@@ -258,7 +249,7 @@ TileLengthMarkers::TileLengthMarkers() :
 		m_markerTilePartIndex(0),
 		m_curr_vec(nullptr),
 		m_stream(nullptr),
-		m_tlm_start_stream_position(0) {
+		streamStart(0) {
 }
 TileLengthMarkers::TileLengthMarkers(BufferedStream *stream): TileLengthMarkers() {
 	m_stream = stream;
@@ -343,7 +334,7 @@ void TileLengthMarkers::push(uint8_t i_TLM, TilePartLengthInfo info) {
 		m_markers->operator[](i_TLM) = vec;
 	}
 }
-void TileLengthMarkers::getInit(void){
+void TileLengthMarkers::rewind(void){
 	m_markerIndex = 0;
 	m_markerTilePartIndex = 0;
 	m_curr_vec = nullptr;
@@ -373,7 +364,7 @@ TilePartLengthInfo TileLengthMarkers::getNext(void){
 }
 bool TileLengthMarkers::skipTo(uint16_t skipTileIndex, BufferedStream *stream,uint64_t firstSotPos){
 	assert(stream);
-	getInit();
+	rewind();
 	auto tl = getNext();
 	uint16_t tileIndex = 0;
 	uint64_t skip = 0;
@@ -392,7 +383,7 @@ bool TileLengthMarkers::skipTo(uint16_t skipTileIndex, BufferedStream *stream,ui
 bool TileLengthMarkers::writeBegin(uint16_t numTilePartsTotal) {
 	uint32_t tlm_size = tlm_marker_start_bytes 	+ tlmMarkerBytesPerTilePart * numTilePartsTotal;
 
-	m_tlm_start_stream_position = m_stream->tell();
+	streamStart = m_stream->tell();
 
 	/* TLM */
 	if (!m_stream->write_short(J2K_MS_TLM))
@@ -417,7 +408,7 @@ void TileLengthMarkers::writeUpdate(uint16_t tileIndex, uint32_t tile_part_size)
     push(m_markerIndex,	TilePartLengthInfo(tileIndex,tile_part_size));
 }
 bool TileLengthMarkers::writeEnd(void) {
-    uint64_t tlm_position = m_tlm_start_stream_position+ tlm_marker_start_bytes;
+    uint64_t tlm_position = streamStart+ tlm_marker_start_bytes;
 	uint64_t current_position = m_stream->tell();
 
 	if (!m_stream->seek(tlm_position))
@@ -454,225 +445,6 @@ bool TileLengthMarkers::addTileMarkerInfo(uint16_t tileno,
 	return true;
 }
 
-PacketLengthMarkers::PacketLengthMarkers() :
-		m_markers(new PL_MAP()),
-		m_markerIndex(0),
-		m_curr_vec(nullptr),
-		m_packetIndex(0),
-		m_packet_len(0),
-		m_marker_bytes_written(0),
-		m_total_bytes_written(0),
-		m_marker_len_cache(0),
-		m_stream(nullptr)
-{ }
-PacketLengthMarkers::PacketLengthMarkers(BufferedStream *strm) : PacketLengthMarkers()
-{
-	m_stream = strm;
-	writeInit();
-}
-PacketLengthMarkers::~PacketLengthMarkers() {
-	if (m_markers) {
-		for (auto it = m_markers->begin(); it != m_markers->end(); it++)
-			delete it->second;
-		delete m_markers;
-	}
-}
-void PacketLengthMarkers::writeInit(void) {
-	readInitIndex(0);
-	m_total_bytes_written = 0;
-	m_marker_bytes_written = 0;
-	m_marker_len_cache = 0;
-}
-void PacketLengthMarkers::writeNext(uint32_t len) {
-	assert(len);
-	m_curr_vec->push_back(len);
-}
-void PacketLengthMarkers::writeIncrement(uint32_t bytes) {
-	m_marker_bytes_written += bytes;
-	m_total_bytes_written += bytes;
-}
-void PacketLengthMarkers::writeMarkerLength(){
-	// write marker length
-	if (m_marker_len_cache){
-		uint64_t current_pos = m_stream->tell();
-		m_stream->seek(m_marker_len_cache);
-		//do not include 2 bytes for marker itself
-		m_stream->write_short((uint16_t) (m_marker_bytes_written - 2));
-		m_stream->seek(current_pos);
-		m_marker_len_cache = 0;
-		m_marker_bytes_written = 0;
-	}
-	assert(m_marker_bytes_written == 0);
-}
-// check if we need to start a new marker
-void PacketLengthMarkers::writeMarkerHeader() {
-	// 5 bytes worst-case to store a packet length
-	if (m_total_bytes_written == 0
-			|| (m_marker_bytes_written >= available_packet_len_bytes_per_plt - 5)) {
-
-		// complete current marker
-		writeMarkerLength();
-
-		// begin new marker
-		m_stream->write_short(J2K_MS_PLT);
-		writeIncrement(2);
-
-		// cache location of marker length and skip over
-		m_marker_len_cache = m_stream->tell();
-		m_stream->skip(2);
-		writeIncrement(2);
-	}
-}
-uint32_t PacketLengthMarkers::write() {
-	writeMarkerHeader();
-	for (auto map_iter = m_markers->begin(); map_iter != m_markers->end();
-			++map_iter) {
-
-		// write index
-		m_stream->write_byte(map_iter->first);
-		writeIncrement(1);
-
-		// write marker lengths
-		for (auto val_iter = map_iter->second->begin();
-				val_iter != map_iter->second->end(); ++val_iter) {
-			//check if we need to start a new PLT marker segment
-			writeMarkerHeader();
-
-			// write from MSB down to LSB
-			uint32_t val = *val_iter;
-			uint32_t numbits = floorlog2<uint32_t>(val) + 1;
-			uint32_t numbytes = (numbits + 6) / 7;
-			assert(numbytes <= 5);
-
-			// write period
-			uint8_t temp[5];
-			int32_t counter = (int32_t)(numbytes - 1);
-			temp[counter--] = (val & 0x7F);
-			val = (uint32_t) (val >> 7);
-
-			//write commas (backwards from LSB to MSB)
-			while (val) {
-				uint8_t b = (uint8_t) ((val & 0x7F) | 0x80);
-				temp[counter--] = b;
-				val = (uint32_t) (val >> 7);
-			}
-			assert(counter == -1);
-			uint32_t written = (uint32_t)m_stream->write_bytes(temp, numbytes);
-			assert(written == numbytes);
-			(void)written;
-			writeIncrement(numbytes);
-		}
-	}
-	// write final marker length
-	writeMarkerLength();
-	return m_total_bytes_written;
-}
-
-bool PacketLengthMarkers::readPLM(uint8_t *p_header_data, uint16_t header_size){
-	if (header_size < 1) {
-		GRK_ERROR("PLM marker segment too short");
-		return false;
-	}
-	// Zplm
-	uint8_t Zplm = *p_header_data++;
-	--header_size;
-	readInitIndex(Zplm);
-	while (header_size > 0) {
-		// Nplm
-		uint8_t Nplm = *p_header_data++;
-		if (header_size < (1 + Nplm)) {
-			GRK_ERROR("Malformed PLM marker segment");
-			return false;
-		}
-		for (uint32_t i = 0; i < Nplm; ++i) {
-			uint8_t tmp = *p_header_data;
-			++p_header_data;
-			readNext(tmp);
-		}
-		header_size = (uint16_t)(header_size - (1 + Nplm));
-		if (m_packet_len != 0) {
-			GRK_ERROR("Malformed PLM marker segment");
-			return false;
-		}
-	}
-	return true;
-}
-bool PacketLengthMarkers::readPLT(uint8_t *p_header_data, uint16_t header_size){
-	if (header_size < 1) {
-		GRK_ERROR("PLT marker segment too short");
-		return false;
-	}
-
-	/* Zplt */
-	uint8_t Zpl = *p_header_data++;
-	--header_size;
-	readInitIndex(Zpl);
-	for (uint32_t i = 0; i < header_size; ++i) {
-		/* Iplt_ij */
-		uint8_t tmp = *p_header_data++;
-		readNext(tmp);
-	}
-	if (m_packet_len != 0) {
-		GRK_ERROR("Malformed PLT marker segment");
-		return false;
-	}
-	return true;
-}
-void PacketLengthMarkers::readInitIndex(uint8_t index) {
-	m_markerIndex = index;
-	m_packet_len = 0;
-	auto pair = m_markers->find(m_markerIndex);
-	if (pair != m_markers->end()) {
-		m_curr_vec = pair->second;
-	} else {
-		m_curr_vec = new PL_INFO_VEC();
-		m_markers->operator[](m_markerIndex) = m_curr_vec;
-	}
-}
-void PacketLengthMarkers::readNext(uint8_t Iplm) {
-	/* take only the lower seven bits */
-	m_packet_len |= (Iplm & 0x7f);
-	if (Iplm & 0x80) {
-		m_packet_len <<= 7;
-	} else {
-		assert(m_curr_vec);
-		m_curr_vec->push_back(m_packet_len);
-		//GRK_INFO("Packet length: (%u, %u)", Zpl, packet_len);
-		m_packet_len = 0;
-	}
-}
-void PacketLengthMarkers::getInit(void) {
-	m_packetIndex = 0;
-	m_markerIndex = 0;
-	m_curr_vec = nullptr;
-	if (m_markers) {
-		auto pair = m_markers->find(0);
-		if (pair != m_markers->end()) {
-			m_curr_vec = pair->second;
-		}
-	}
-}
-// note: packet length must be at least 1, so 0 indicates
-// no packet length available
-uint32_t PacketLengthMarkers::getNext(void) {
-	if (!m_markers)
-		return 0;
-	if (m_curr_vec) {
-		if (m_packetIndex == m_curr_vec->size()) {
-			m_markerIndex++;
-			if (m_markerIndex < m_markers->size()) {
-				m_curr_vec = m_markers->operator[](m_markerIndex);
-				m_packetIndex = 0;
-			} else {
-				m_curr_vec = nullptr;
-			}
-		}
-		if (m_curr_vec)
-			return m_curr_vec->operator[](m_packetIndex++);
-	}
-	return 0;
-}
-
 PacketInfo::PacketInfo(void) :	headerLength(0),
 								packetLength(0),
 								parsedData(false)

src/lib/jp2/cache/LengthCache.h

@@ -118,7 +118,7 @@ struct TileLengthMarkers {
 	~TileLengthMarkers();
 
 	bool read(uint8_t *p_header_data, uint16_t header_size);
-	void getInit(void);
+	void rewind(void);
 	TilePartLengthInfo getNext(void);
 	bool skipTo(uint16_t skipTileIndex, BufferedStream *stream, uint64_t firstSotPos);
 
@@ -145,46 +145,9 @@ struct TileLengthMarkers {
 	uint8_t m_markerTilePartIndex;
 	TL_INFO_VEC *m_curr_vec;
 	BufferedStream *m_stream;
-	uint64_t m_tlm_start_stream_position;
+	uint64_t streamStart;
 };
 
-typedef std::vector<uint32_t> PL_INFO_VEC;
-
-// map of (PLT/PLM marker id) => (packet length vector)
-typedef std::map<uint8_t, PL_INFO_VEC*> PL_MAP;
-
-struct PacketLengthMarkers {
-	PacketLengthMarkers(void);
-	PacketLengthMarkers(BufferedStream *strm);
-	~PacketLengthMarkers(void);
-
-	// decompressor  packet lengths
-	bool readPLT(uint8_t *p_header_data, uint16_t header_size);
-	bool readPLM(uint8_t *p_header_data, uint16_t header_size);
-	void getInit(void);
-	uint32_t getNext(void);
-
-	// compressor packet lengths
-	void writeInit(void);
-	void writeNext(uint32_t len);
-	uint32_t write();
-private:
-	void readInitIndex(uint8_t index);
-	void readNext(uint8_t Iplm);
-	void writeMarkerHeader(void);
-	void writeMarkerLength();
-	void writeIncrement(uint32_t bytes);
-
-	PL_MAP *m_markers;
-	uint8_t m_markerIndex;
-	PL_INFO_VEC *m_curr_vec;
-	size_t m_packetIndex;
-	uint32_t m_packet_len;
-	uint32_t m_marker_bytes_written;
-	uint32_t m_total_bytes_written;
-	uint64_t m_marker_len_cache;
-	BufferedStream *m_stream;
-};
 
 struct PacketInfo{
 	PacketInfo(void);

src/lib/jp2/grk_includes.h

@@ -107,6 +107,7 @@
 #include "Quantizer.h"
 #include "Profile.h"
 #include "LengthCache.h"
+#include "PacketLengthMarkers.h"
 #include "SIZMarker.h"
 #include "PPMMarker.h"
 #include "SOTMarker.h"

src/lib/jp2/t2/T2Decompress.cpp

@@ -125,7 +125,7 @@ bool T2Decompress::decompressPackets(uint16_t tile_no,
 	// so we disable packet length markers if we have both PLT and PLM
 	bool usePlt = packetLengths && !cp->plm_markers;
 	if (usePlt)
-		packetLengths->getInit();
+		packetLengths->rewind();
 	for (uint32_t pino = 0; pino <= tcp->numpocs; ++pino) {
 		auto currPi = pi + pino;
 		if (currPi->prog.progression == GRK_PROG_UNKNOWN) {