Skip to content

Commit 2bf89c7

Browse files
author
Aaron Boxer
committed
T2: simplify
1 parent 44937d9 commit 2bf89c7

File tree

3 files changed

+60
-91
lines changed

3 files changed

+60
-91
lines changed

‎src/lib/jp2/t1/Codeblock.h‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,14 +25,12 @@ struct Segment {
2525
clear();
2626
}
2727
void clear() {
28-
dataindex = 0;
2928
numpasses = 0;
3029
len = 0;
3130
maxpasses = 0;
3231
numPassesInPacket = 0;
3332
numBytesInPacket = 0;
3433
}
35-
uint32_t dataindex; // segment data offset in contiguous memory block
3634
uint32_t numpasses; // number of passes in segment
3735
uint32_t len; // total length of segment
3836
uint32_t maxpasses; // maximum number of passes in segment

‎src/lib/jp2/t2/T2Decompress.cpp‎

Lines changed: 55 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -152,13 +152,13 @@ bool T2Decompress::decompressPackets(uint16_t tile_no,
152152
bool T2Decompress::decompressPacket(TileCodingParams *p_tcp,
153153
const PacketIter *p_pi,
154154
SparseBuffer *src_buf,
155-
uint64_t *p_data_read) {
155+
uint64_t *dataRead) {
156156
auto p_tile = tileProcessor->tile;
157157
auto res = &p_tile->comps[p_pi->compno].tileCompResolution[p_pi->resno];
158158
bool read_data;
159159
uint64_t bytesRead = 0;
160160
uint64_t nb_total_bytes_read = 0;
161-
*p_data_read = 0;
161+
*dataRead = 0;
162162
if (!readPacketHeader(p_tcp, p_pi, &read_data, src_buf, &bytesRead))
163163
return false;
164164
nb_total_bytes_read += bytesRead;
@@ -171,7 +171,7 @@ bool T2Decompress::decompressPacket(TileCodingParams *p_tcp,
171171
}
172172
nb_total_bytes_read += bytesRead;
173173
}
174-
*p_data_read = nb_total_bytes_read;
174+
*dataRead = nb_total_bytes_read;
175175
return true;
176176
}
177177
void T2Decompress::initSegment(DecompressCodeblock *cblk, uint32_t index, uint8_t cblk_sty,
@@ -197,7 +197,7 @@ bool T2Decompress::readPacketHeader(TileCodingParams *p_tcp,
197197
const PacketIter *p_pi,
198198
bool *p_is_data_present,
199199
SparseBuffer *src_buf,
200-
uint64_t *p_data_read) {
200+
uint64_t *dataRead) {
201201
auto p_tile = tileProcessor->tile;
202202
auto res = &p_tile->comps[p_pi->compno].tileCompResolution[p_pi->resno];
203203
auto p_src_data = src_buf->getCurrentChunkPtr();
@@ -221,8 +221,8 @@ bool T2Decompress::readPacketHeader(TileCodingParams *p_tcp,
221221
available_bytes -= 6;
222222
}
223223
}
224-
uint8_t **header_data_start = &active_src;
225-
size_t *remaining_length = &available_bytes;
224+
auto header_data_start = &active_src;
225+
auto remaining_length = &available_bytes;
226226
auto cp = tileProcessor->m_cp;
227227
if (cp->ppm_marker) {
228228
if (tileProcessor->m_tileIndex >= cp->ppm_marker->m_tile_packet_headers.size()){
@@ -239,7 +239,7 @@ bool T2Decompress::readPacketHeader(TileCodingParams *p_tcp,
239239
}
240240
if (*remaining_length==0)
241241
throw TruncatedPacketHeaderException();
242-
uint8_t *header_data = *header_data_start;
242+
auto header_data = *header_data_start;
243243
uint32_t present = 0;
244244
std::unique_ptr<BitIO> bio(new BitIO(header_data, *remaining_length, false));
245245
try {
@@ -331,7 +331,7 @@ bool T2Decompress::readPacketHeader(TileCodingParams *p_tcp,
331331
cblk->numlenbits += increment;
332332
uint32_t segno = 0;
333333
if (!cblk->getNumSegments()) {
334-
initSegment(cblk, segno,p_tcp->tccps[p_pi->compno].cblk_sty, true);
334+
initSegment(cblk, 0,p_tcp->tccps[p_pi->compno].cblk_sty, true);
335335
} else {
336336
segno = cblk->getNumSegments() - 1;
337337
if (cblk->getSegment(segno)->numpasses == cblk->getSegment(segno)->maxpasses) {
@@ -409,83 +409,69 @@ bool T2Decompress::readPacketHeader(TileCodingParams *p_tcp,
409409
auto header_length = (size_t) (header_data - *header_data_start);
410410
//GRK_INFO("hdrlen=%u ", header_length);
411411
//GRK_INFO("packet body\n");
412-
*remaining_length -= header_length;
413-
*header_data_start += header_length;
414-
*p_is_data_present = present;
415-
*p_data_read = (uint32_t) (active_src - p_src_data);
416-
src_buf->incrementCurrentChunkOffset(*p_data_read);
412+
*remaining_length -= header_length;
413+
*header_data_start += header_length;
414+
*p_is_data_present = present;
415+
*dataRead = (uint32_t) (active_src - p_src_data);
416+
src_buf->incrementCurrentChunkOffset(*dataRead);
417417

418-
if (!present && !*p_data_read)
418+
if (!present && !*dataRead)
419419
throw TruncatedPacketHeaderException();
420420

421421
return true;
422422
}
423423
bool T2Decompress::readPacketData(Resolution *res,
424424
const PacketIter *p_pi,
425425
SparseBuffer *src_buf,
426-
uint64_t *p_data_read) {
426+
uint64_t *dataRead) {
427427
for (uint32_t bandIndex = 0; bandIndex < res->numTileBandWindows; ++bandIndex) {
428428
auto band = res->tileBand + bandIndex;
429+
if (band->isEmpty())
430+
continue;
429431
auto prc = band->getPrecinct(p_pi->precinctIndex);
430432
if (!prc)
431433
continue;
432434
for (uint64_t cblkno = 0; cblkno < prc->getNumCblks(); ++cblkno) {
433435
auto cblk = prc->getDecompressedBlockPtr(cblkno);
434-
if (!cblk->numPassesInPacket) {
435-
++cblk;
436+
if (!cblk->numPassesInPacket)
436437
continue;
437-
}
438-
Segment *seg = nullptr;
439-
if (!cblk->getNumSegments()) {
438+
439+
auto seg = cblk->getCurrentSegment();
440+
if (!seg || (seg->numpasses == seg->maxpasses))
440441
seg = cblk->nextSegment();
441-
cblk->compressedStream.len = 0;
442-
} else {
443-
seg = cblk->getCurrentSegment();
444-
if (seg->numpasses == seg->maxpasses) {
445-
seg = cblk->nextSegment();
446-
}
447-
}
448442
uint32_t numPassesInPacket = cblk->numPassesInPacket;
449443
do {
450444
size_t maxLen = src_buf->getCurrentChunkLength();
451445
if (maxLen == 0)
452446
return true;
453-
// reject truncated packet
454447
if (((seg->numBytesInPacket) > maxLen)) {
455448
// HT doesn't tolerate truncated code blocks since decoding runs both forward and reverse.
456449
// So, in this case, we ignore the entire code block
457-
if (tileProcessor->m_cp->tcps[0].getIsHT()){
450+
if (tileProcessor->m_cp->tcps[0].getIsHT())
458451
cblk->cleanUpSegBuffers();
459-
}
460452
seg->numBytesInPacket = 0;
461453
seg->numpasses = 0;
462454
break;
463455
}
464-
//initialize dataindex to current contiguous size of code block
465-
if (seg->numpasses == 0)
466-
seg->dataindex = (uint32_t) cblk->compressedStream.len;
467-
468-
// only add segment to seg_buffers if length is greater than zero
469456
if (seg->numBytesInPacket) {
470457
// sanity check on seg->numBytesInPacket
471458
if (UINT_MAX - seg->numBytesInPacket < seg->len){
472459
GRK_ERROR("Segment packet length %d plus total segment length %d must be less than 2^32",
473460
seg->numBytesInPacket, seg->len);
474461
return false;
475462
}
476-
size_t max_seg_len = src_buf->getCurrentChunkLength();
463+
size_t maxSegmentLength = src_buf->getCurrentChunkLength();
477464
// correct for truncated packet
478-
if (seg->numBytesInPacket > max_seg_len)
479-
seg->numBytesInPacket = (uint32_t)max_seg_len;
480-
cblk->seg_buffers.push_back(new grkBufferU8(src_buf->getCurrentChunkPtr(),
481-
seg->numBytesInPacket, false));
482-
*(p_data_read) += seg->numBytesInPacket;
465+
if (seg->numBytesInPacket > maxSegmentLength)
466+
seg->numBytesInPacket = (uint32_t)maxSegmentLength;
467+
cblk->seg_buffers.push_back(new grkBufferU8(src_buf->getCurrentChunkPtr(),seg->numBytesInPacket, false));
483468
src_buf->incrementCurrentChunkOffset(seg->numBytesInPacket);
484-
cblk->compressedStream.len += seg->numBytesInPacket;
485-
seg->len += seg->numBytesInPacket;
469+
*dataRead += seg->numBytesInPacket;
470+
cblk->compressedStream.len += seg->numBytesInPacket;
471+
seg->len += seg->numBytesInPacket;
486472
}
487-
seg->numpasses += seg->numPassesInPacket;
488-
numPassesInPacket -= seg->numPassesInPacket;
473+
seg->numpasses += seg->numPassesInPacket;
474+
numPassesInPacket -= seg->numPassesInPacket;
489475
if (numPassesInPacket > 0)
490476
seg = cblk->nextSegment();
491477
} while (numPassesInPacket > 0);
@@ -497,39 +483,38 @@ bool T2Decompress::readPacketData(Resolution *res,
497483
bool T2Decompress::skipPacket(TileCodingParams *p_tcp,
498484
PacketIter *p_pi,
499485
SparseBuffer *src_buf,
500-
uint64_t *p_data_read) {
501-
uint64_t max_length = (uint64_t) src_buf->getCurrentChunkLength();
486+
uint64_t *dataRead) {
487+
uint64_t maxDataLength = (uint64_t) src_buf->getCurrentChunkLength();
502488
auto p_tile = tileProcessor->tile;
503489

504-
*p_data_read = 0;
490+
*dataRead = 0;
505491
uint64_t bytesRead = 0;
506492
bool read_data;
507493
if (!readPacketHeader(p_tcp, p_pi, &read_data, src_buf, &bytesRead))
508494
return false;
509-
uint64_t nb_totabytes_read = bytesRead;
510-
max_length -= bytesRead;
495+
uint64_t totalBytesRead = bytesRead;
496+
maxDataLength -= bytesRead;
511497

512498
/* we should read data for the packet */
513499
if (read_data) {
514500
bytesRead = 0;
515501
if (!skipPacketData(&p_tile->comps[p_pi->compno].tileCompResolution[p_pi->resno], p_pi,
516-
&bytesRead, max_length)) {
502+
&bytesRead, maxDataLength)) {
517503
return false;
518504
}
519505
src_buf->incrementCurrentChunkOffset(bytesRead);
520-
nb_totabytes_read += bytesRead;
506+
totalBytesRead += bytesRead;
521507
}
522-
*p_data_read = nb_totabytes_read;
508+
*dataRead = totalBytesRead;
523509

524510
return true;
525511
}
526512
bool T2Decompress::skipPacketData(Resolution *res,
527513
PacketIter *p_pi,
528-
uint64_t *p_data_read,
529-
uint64_t max_length) {
530-
*p_data_read = 0;
514+
uint64_t *dataRead,
515+
uint64_t maxDataLength) {
531516
for (uint32_t bandIndex = 0; bandIndex < res->numTileBandWindows; ++bandIndex) {
532-
if (*p_data_read == max_length)
517+
if (*dataRead == maxDataLength)
533518
return true;
534519
auto band = res->tileBand + bandIndex;
535520
if (band->isEmpty())
@@ -538,40 +523,26 @@ bool T2Decompress::skipPacketData(Resolution *res,
538523
if (!prc)
539524
continue;
540525
for (uint64_t cblkno = 0; cblkno < prc->getNumCblks(); ++cblkno) {
541-
if (max_length - *p_data_read == 0)
542-
return true;
543526
auto cblk = prc->getDecompressedBlockPtr(cblkno);
544-
if (!cblk->numPassesInPacket) {
545-
/* nothing to do */
546-
++cblk;
527+
if (!cblk->numPassesInPacket)
547528
continue;
548-
}
549-
Segment *seg = nullptr;
550-
if (!cblk->getNumSegments()) {
529+
auto seg = cblk->getCurrentSegment();
530+
if (!seg || (seg->numpasses == seg->maxpasses))
551531
seg = cblk->nextSegment();
552-
cblk->compressedStream.len = 0;
553-
} else {
554-
seg = cblk->getCurrentSegment();
555-
if (seg->numpasses == seg->maxpasses)
556-
seg = cblk->nextSegment();
557-
}
558532
uint32_t numPassesInPacket = cblk->numPassesInPacket;
559533
do {
560-
if (*p_data_read == max_length)
561-
return true;
562-
/* Check possible overflow */
563-
if (((*p_data_read + seg->numBytesInPacket) > max_length)) {
564-
GRK_WARN("skip: segment bytes (%u) too large for remaining stream bytes (%u) in codeblock %u (p=%u, b=%u, r=%u, c=%u). Truncating segment",
565-
seg->numBytesInPacket, max_length - *p_data_read, cblkno,
534+
if (((*dataRead + seg->numBytesInPacket) > maxDataLength)) {
535+
GRK_WARN("skip packet data: segment bytes (%u) too large for remaining stream bytes (%u) in "
536+
"codeblock %u (p=%u, b=%u, r=%u, c=%u). Truncating segment",
537+
seg->numBytesInPacket, maxDataLength - *dataRead, cblkno,
566538
p_pi->precinctIndex, bandIndex, p_pi->resno, p_pi->compno);
567-
seg->numBytesInPacket = (uint32_t)(max_length - *p_data_read);
539+
seg->numBytesInPacket = (uint32_t)(maxDataLength - *dataRead);
568540
}
569-
570-
//GRK_INFO( "skip packet: p_data_read = %u, bytes in packet = %u ",
571-
// *p_data_read, seg->numBytesInPacket);
572-
*(p_data_read) += seg->numBytesInPacket;
573-
seg->numpasses += seg->numPassesInPacket;
574-
numPassesInPacket -= seg->numPassesInPacket;
541+
*dataRead += seg->numBytesInPacket;
542+
seg->numpasses += seg->numPassesInPacket;
543+
numPassesInPacket -= seg->numPassesInPacket;
544+
if (*dataRead == maxDataLength)
545+
return true;
575546
if (numPassesInPacket > 0)
576547
seg = cblk->nextSegment();
577548
} while (numPassesInPacket > 0);

‎src/lib/jp2/t2/T2Decompress.h‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -63,23 +63,23 @@ struct T2Decompress {
6363
bool skipPacket(TileCodingParams *p_tcp,
6464
PacketIter *p_pi,
6565
SparseBuffer *src_buf,
66-
uint64_t *p_data_read);
66+
uint64_t *dataRead);
6767

6868
bool readPacketHeader(TileCodingParams *p_tcp,
6969
const PacketIter *p_pi,
7070
bool *p_is_data_present,
7171
SparseBuffer *src_buf,
72-
uint64_t *p_data_read);
72+
uint64_t *dataRead);
7373

7474
bool readPacketData(Resolution *l_res,
7575
const PacketIter *p_pi,
7676
SparseBuffer *src_buf,
77-
uint64_t *p_data_read);
77+
uint64_t *dataRead);
7878

7979
bool skipPacketData(Resolution *l_res,
8080
PacketIter *p_pi,
81-
uint64_t *p_data_read,
82-
uint64_t max_length);
81+
uint64_t *dataRead,
82+
uint64_t maxDataLength);
8383

8484
void initSegment(DecompressCodeblock *cblk,
8585
uint32_t index,

0 commit comments

Comments
 (0)