From 78f588a83356be146b404c161aedcd876e1ec7a7 Mon Sep 17 00:00:00 2001 From: Emmanuel Marty Date: Tue, 29 Oct 2019 10:45:57 +0100 Subject: [PATCH] Clarify defines --- src/shrink_block_v1.c | 54 +++++++++++----------- src/shrink_block_v2.c | 103 +++++++++++++++++++++++------------------- src/shrink_context.c | 8 ++-- src/shrink_context.h | 10 +++- 4 files changed, 95 insertions(+), 80 deletions(-) diff --git a/src/shrink_block_v1.c b/src/shrink_block_v1.c index 8fcfe5f..47bf019 100644 --- a/src/shrink_block_v1.c +++ b/src/shrink_block_v1.c @@ -163,18 +163,18 @@ static void lzsa_optimize_forward_v1(lzsa_compressor *pCompressor, lzsa_match *p const int nDisableScore = nReduce ? 0 : (2 * BLOCK_SIZE); int i, j, n; - memset(arrival + (nStartOffset << MATCHES_PER_OFFSET_SHIFT), 0, sizeof(lzsa_arrival) * ((nEndOffset - nStartOffset) << MATCHES_PER_OFFSET_SHIFT)); + memset(arrival + (nStartOffset << MATCHES_PER_ARRIVAL_SHIFT), 0, sizeof(lzsa_arrival) * ((nEndOffset - nStartOffset) << MATCHES_PER_ARRIVAL_SHIFT)); - arrival[nStartOffset << MATCHES_PER_OFFSET_SHIFT].from_slot = -1; + arrival[nStartOffset << MATCHES_PER_ARRIVAL_SHIFT].from_slot = -1; for (i = nStartOffset; i != (nEndOffset - 1); i++) { int m; - for (j = 0; j < NMATCHES_PER_OFFSET && arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].from_slot; j++) { - int nPrevCost = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].cost; + for (j = 0; j < NMATCHES_PER_ARRIVAL && arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].from_slot; j++) { + int nPrevCost = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].cost; int nCodingChoiceCost = nPrevCost + 8 /* literal */; - int nScore = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].score + 1; - int nNumLiterals = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].num_literals + 1; + int nScore = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].score + 1; + int nNumLiterals = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].num_literals + 1; if (nNumLiterals == LITERALS_RUN_LEN_V1 || nNumLiterals == 256 || nNumLiterals == 512) { nCodingChoiceCost += 8; @@ -183,15 +183,15 @@ static void lzsa_optimize_forward_v1(lzsa_compressor *pCompressor, lzsa_match *p if (!nFavorRatio && nNumLiterals == 1) nCodingChoiceCost += MODESWITCH_PENALTY; - for (n = 0; n < NMATCHES_PER_OFFSET /* we only need the literals + short match cost + long match cost cases */; n++) { - lzsa_arrival *pDestArrival = &arrival[((i + 1) << MATCHES_PER_OFFSET_SHIFT) + n]; + for (n = 0; n < NMATCHES_PER_ARRIVAL /* we only need the literals + short match cost + long match cost cases */; n++) { + lzsa_arrival *pDestArrival = &arrival[((i + 1) << MATCHES_PER_ARRIVAL_SHIFT) + n]; if (pDestArrival->from_slot == 0 || nCodingChoiceCost < pDestArrival->cost || (nCodingChoiceCost == pDestArrival->cost && nScore < (pDestArrival->score + nDisableScore))) { - memmove(&arrival[((i + 1) << MATCHES_PER_OFFSET_SHIFT) + n + 1], - &arrival[((i + 1) << MATCHES_PER_OFFSET_SHIFT) + n], - sizeof(lzsa_arrival) * (NMATCHES_PER_OFFSET - n - 1)); + memmove(&arrival[((i + 1) << MATCHES_PER_ARRIVAL_SHIFT) + n + 1], + &arrival[((i + 1) << MATCHES_PER_ARRIVAL_SHIFT) + n], + sizeof(lzsa_arrival) * (NMATCHES_PER_ARRIVAL - n - 1)); pDestArrival->cost = nCodingChoiceCost; pDestArrival->from_pos = i; @@ -200,15 +200,15 @@ static void lzsa_optimize_forward_v1(lzsa_compressor *pCompressor, lzsa_match *p pDestArrival->match_len = 0; pDestArrival->num_literals = nNumLiterals; pDestArrival->score = nScore; - pDestArrival->rep_offset = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_offset; + pDestArrival->rep_offset = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_offset; break; } } } - const lzsa_match *match = pCompressor->match + (i << 3); + const lzsa_match *match = pCompressor->match + (i << MATCHES_PER_INDEX_SHIFT_V1); - for (m = 0; m < 8 && match[m].length; m++) { + for (m = 0; m < NMATCHES_PER_INDEX_V1 && match[m].length; m++) { int nMatchLen = match[m].length; int nMatchOffsetCost = lzsa_get_offset_cost_v1(match[m].offset); int nStartingMatchLen, k; @@ -223,33 +223,33 @@ static void lzsa_optimize_forward_v1(lzsa_compressor *pCompressor, lzsa_match *p for (k = nStartingMatchLen; k <= nMatchLen; k++) { int nMatchLenCost = lzsa_get_match_varlen_size_v1(k - MIN_MATCH_SIZE_V1); - for (j = 0; j < NMATCHES_PER_OFFSET && arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].from_slot; j++) { - int nPrevCost = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].cost; + for (j = 0; j < NMATCHES_PER_ARRIVAL && arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].from_slot; j++) { + int nPrevCost = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].cost; int nCodingChoiceCost = nPrevCost + 8 /* token */ /* the actual cost of the literals themselves accumulates up the chain */ + nMatchOffsetCost + nMatchLenCost; - int nScore = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].score + 5; + int nScore = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].score + 5; int exists = 0; - if (!nFavorRatio && !arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].num_literals) + if (!nFavorRatio && !arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].num_literals) nCodingChoiceCost += MODESWITCH_PENALTY; for (n = 0; - n < NMATCHES_PER_OFFSET && arrival[((i + k) << MATCHES_PER_OFFSET_SHIFT) + n].from_slot && arrival[((i + k) << MATCHES_PER_OFFSET_SHIFT) + n].cost <= nCodingChoiceCost; + n < NMATCHES_PER_ARRIVAL && arrival[((i + k) << MATCHES_PER_ARRIVAL_SHIFT) + n].from_slot && arrival[((i + k) << MATCHES_PER_ARRIVAL_SHIFT) + n].cost <= nCodingChoiceCost; n++) { - if (lzsa_get_offset_cost_v1(arrival[((i + k) << MATCHES_PER_OFFSET_SHIFT) + n].rep_offset) == lzsa_get_offset_cost_v1(match[m].offset)) { + if (lzsa_get_offset_cost_v1(arrival[((i + k) << MATCHES_PER_ARRIVAL_SHIFT) + n].rep_offset) == lzsa_get_offset_cost_v1(match[m].offset)) { exists = 1; break; } } - for (n = 0; !exists && n < NMATCHES_PER_OFFSET /* we only need the literals + short match cost + long match cost cases */; n++) { - lzsa_arrival *pDestArrival = &arrival[((i + k) << MATCHES_PER_OFFSET_SHIFT) + n]; + for (n = 0; !exists && n < NMATCHES_PER_ARRIVAL /* we only need the literals + short match cost + long match cost cases */; n++) { + lzsa_arrival *pDestArrival = &arrival[((i + k) << MATCHES_PER_ARRIVAL_SHIFT) + n]; if (pDestArrival->from_slot == 0 || nCodingChoiceCost < pDestArrival->cost || (nCodingChoiceCost == pDestArrival->cost && nScore < (pDestArrival->score + nDisableScore))) { - memmove(&arrival[((i + k) << MATCHES_PER_OFFSET_SHIFT) + n + 1], - &arrival[((i + k) << MATCHES_PER_OFFSET_SHIFT) + n], - sizeof(lzsa_arrival) * (NMATCHES_PER_OFFSET - n - 1)); + memmove(&arrival[((i + k) << MATCHES_PER_ARRIVAL_SHIFT) + n + 1], + &arrival[((i + k) << MATCHES_PER_ARRIVAL_SHIFT) + n], + sizeof(lzsa_arrival) * (NMATCHES_PER_ARRIVAL - n - 1)); pDestArrival->cost = nCodingChoiceCost; pDestArrival->from_pos = i; @@ -267,7 +267,7 @@ static void lzsa_optimize_forward_v1(lzsa_compressor *pCompressor, lzsa_match *p } } - lzsa_arrival *end_arrival = &arrival[(i << MATCHES_PER_OFFSET_SHIFT) + 0]; + lzsa_arrival *end_arrival = &arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + 0]; pBestMatch[i].length = 0; pBestMatch[i].offset = 0; @@ -275,7 +275,7 @@ static void lzsa_optimize_forward_v1(lzsa_compressor *pCompressor, lzsa_match *p pBestMatch[end_arrival->from_pos].length = end_arrival->match_len; pBestMatch[end_arrival->from_pos].offset = end_arrival->match_offset; - end_arrival = &arrival[(end_arrival->from_pos << MATCHES_PER_OFFSET_SHIFT) + (end_arrival->from_slot - 1)]; + end_arrival = &arrival[(end_arrival->from_pos << MATCHES_PER_ARRIVAL_SHIFT) + (end_arrival->from_slot - 1)]; } } diff --git a/src/shrink_block_v2.c b/src/shrink_block_v2.c index 289ba75..e52f9de 100644 --- a/src/shrink_block_v2.c +++ b/src/shrink_block_v2.c @@ -189,22 +189,22 @@ static void lzsa_insert_forward_match_v2(lzsa_compressor *pCompressor, const uns if (nDepth >= 10) return; - for (j = 0; j < NMATCHES_PER_OFFSET && arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].from_slot; j++) { - int nRepOffset = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_offset; + for (j = 0; j < NMATCHES_PER_ARRIVAL && arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].from_slot; j++) { + int nRepOffset = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_offset; - if (nMatchOffset != nRepOffset && nRepOffset && arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_len >= MIN_MATCH_SIZE_V2) { - int nRepPos = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_pos; - int nRepLen = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_len; + if (nMatchOffset != nRepOffset && nRepOffset && arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_len >= MIN_MATCH_SIZE_V2) { + int nRepPos = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_pos; + int nRepLen = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_len; if (nRepPos > nMatchOffset && (nRepPos - nMatchOffset + nRepLen) <= (nEndOffset - LAST_LITERALS) && !memcmp(pInWindow + nRepPos - nRepOffset, pInWindow + nRepPos - nMatchOffset, nRepLen)) { - lzsa_match *fwd_match = pCompressor->match + (nRepPos << 5); + lzsa_match *fwd_match = pCompressor->match + (nRepPos << MATCHES_PER_INDEX_SHIFT_V2); int exists = 0; int r; - for (r = 0; r < 32 && fwd_match[r].length >= MIN_MATCH_SIZE_V2; r++) { + for (r = 0; r < NMATCHES_PER_INDEX_V2 && fwd_match[r].length >= MIN_MATCH_SIZE_V2; r++) { if (fwd_match[r].offset == nMatchOffset) { exists = 1; @@ -216,12 +216,21 @@ static void lzsa_insert_forward_match_v2(lzsa_compressor *pCompressor, const uns } } - if (!exists && r < 32) { + if (!exists && r < NMATCHES_PER_INDEX_V2) { fwd_match[r].offset = nMatchOffset; fwd_match[r].length = nRepLen; lzsa_insert_forward_match_v2(pCompressor, pInWindow, nRepPos, nMatchOffset, nEndOffset, nDepth + 1); } + else if (!exists && r >= NMATCHES_PER_INDEX_V2) { + for (r = NMATCHES_PER_INDEX_V2 - 1; r >= 0; r--) { + if (fwd_match[r].length < nRepLen) { + fwd_match[r].offset = nMatchOffset; + fwd_match[r].length = nRepLen; + break; + } + } + } } } } @@ -243,21 +252,21 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne const int nDisableScore = nReduce ? 0 : (2 * BLOCK_SIZE); int i, j, n; - memset(arrival + (nStartOffset << MATCHES_PER_OFFSET_SHIFT), 0, sizeof(lzsa_arrival) * ((nEndOffset - nStartOffset) << MATCHES_PER_OFFSET_SHIFT)); + memset(arrival + (nStartOffset << MATCHES_PER_ARRIVAL_SHIFT), 0, sizeof(lzsa_arrival) * ((nEndOffset - nStartOffset) << MATCHES_PER_ARRIVAL_SHIFT)); - for (i = (nStartOffset << MATCHES_PER_OFFSET_SHIFT); i != (nEndOffset << MATCHES_PER_OFFSET_SHIFT); i++) { + for (i = (nStartOffset << MATCHES_PER_ARRIVAL_SHIFT); i != (nEndOffset << MATCHES_PER_ARRIVAL_SHIFT); i++) { arrival[i].cost = 0x40000000; } - arrival[nStartOffset << MATCHES_PER_OFFSET_SHIFT].from_slot = -1; + arrival[nStartOffset << MATCHES_PER_ARRIVAL_SHIFT].from_slot = -1; for (i = nStartOffset; i != (nEndOffset - 1); i++) { int m; - for (j = 0; j < NMATCHES_PER_OFFSET && arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].from_slot; j++) { - const int nPrevCost = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].cost & 0x3fffffff; + for (j = 0; j < NMATCHES_PER_ARRIVAL && arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].from_slot; j++) { + const int nPrevCost = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].cost & 0x3fffffff; int nCodingChoiceCost = nPrevCost + 8 /* literal */; - int nNumLiterals = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].num_literals + 1; + int nNumLiterals = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].num_literals + 1; if (nNumLiterals == LITERALS_RUN_LEN_V2) { nCodingChoiceCost += 4; @@ -272,21 +281,21 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne if (!nFavorRatio && nNumLiterals == 1) nCodingChoiceCost += MODESWITCH_PENALTY; - lzsa_arrival *pDestSlots = &arrival[(i + 1) << MATCHES_PER_OFFSET_SHIFT]; - if (nCodingChoiceCost <= pDestSlots[NMATCHES_PER_OFFSET - 1].cost) { + lzsa_arrival *pDestSlots = &arrival[(i + 1) << MATCHES_PER_ARRIVAL_SHIFT]; + if (nCodingChoiceCost <= pDestSlots[NMATCHES_PER_ARRIVAL - 1].cost) { int exists = 0; for (n = 0; - n < NMATCHES_PER_OFFSET && pDestSlots[n].cost <= nCodingChoiceCost; + n < NMATCHES_PER_ARRIVAL && pDestSlots[n].cost <= nCodingChoiceCost; n++) { - if (pDestSlots[n].rep_offset == arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_offset) { + if (pDestSlots[n].rep_offset == arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_offset) { exists = 1; break; } } if (!exists) { - int nScore = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].score + 1; - for (n = 0; n < NMATCHES_PER_OFFSET; n++) { + int nScore = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].score + 1; + for (n = 0; n < NMATCHES_PER_ARRIVAL; n++) { lzsa_arrival *pDestArrival = &pDestSlots[n]; if (nCodingChoiceCost < pDestArrival->cost || (nCodingChoiceCost == pDestArrival->cost && nScore < (pDestArrival->score + nDisableScore))) { @@ -294,7 +303,7 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne if (pDestArrival->from_slot) { memmove(&pDestSlots[n + 1], &pDestSlots[n], - sizeof(lzsa_arrival) * (NMATCHES_PER_OFFSET - n - 1)); + sizeof(lzsa_arrival) * (NMATCHES_PER_ARRIVAL - n - 1)); } pDestArrival->cost = nCodingChoiceCost; @@ -304,9 +313,9 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne pDestArrival->match_len = 0; pDestArrival->num_literals = nNumLiterals; pDestArrival->score = nScore; - pDestArrival->rep_offset = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_offset; - pDestArrival->rep_pos = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_pos; - pDestArrival->rep_len = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_len; + pDestArrival->rep_offset = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_offset; + pDestArrival->rep_pos = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_pos; + pDestArrival->rep_len = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_len; break; } } @@ -314,20 +323,20 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne } } - lzsa_match *match = pCompressor->match + (i << 5); + lzsa_match *match = pCompressor->match + (i << MATCHES_PER_INDEX_SHIFT_V2); - for (m = 0; m < 32 && match[m].length; m++) { + for (m = 0; m < NMATCHES_PER_INDEX_V2 && match[m].length; m++) { int nMatchLen = match[m].length; int nMatchOffset = match[m].offset; int nNoRepmatchOffsetCost = (nMatchOffset <= 32) ? 4 : ((nMatchOffset <= 512) ? 8 : ((nMatchOffset <= (8192 + 512)) ? 12 : 16)); int nStartingMatchLen, k; - int nMaxRepLen[NMATCHES_PER_OFFSET]; + int nMaxRepLen[NMATCHES_PER_ARRIVAL]; if ((i + nMatchLen) > (nEndOffset - LAST_LITERALS)) nMatchLen = nEndOffset - LAST_LITERALS - i; - for (j = 0; j < NMATCHES_PER_OFFSET && arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].from_slot; j++) { - int nRepOffset = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_offset; + for (j = 0; j < NMATCHES_PER_ARRIVAL && arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].from_slot; j++) { + int nRepOffset = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_offset; int nCurMaxRepLen = 0; if (nMatchOffset != nRepOffset && @@ -340,7 +349,7 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne nMaxRepLen[j] = nCurMaxRepLen; } - while (j < NMATCHES_PER_OFFSET) + while (j < NMATCHES_PER_ARRIVAL) nMaxRepLen[j++] = 0; if (nInsertForwardReps) @@ -353,25 +362,25 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne for (k = nStartingMatchLen; k <= nMatchLen; k++) { int nMatchLenCost = lzsa_get_match_varlen_size_v2(k - MIN_MATCH_SIZE_V2); - lzsa_arrival *pDestSlots = &arrival[(i + k) << MATCHES_PER_OFFSET_SHIFT]; + lzsa_arrival *pDestSlots = &arrival[(i + k) << MATCHES_PER_ARRIVAL_SHIFT]; - for (j = 0; j < NMATCHES_PER_OFFSET && arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].from_slot; j++) { - const int nPrevCost = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].cost & 0x3fffffff; - int nRepOffset = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].rep_offset; + for (j = 0; j < NMATCHES_PER_ARRIVAL && arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].from_slot; j++) { + const int nPrevCost = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].cost & 0x3fffffff; + int nRepOffset = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].rep_offset; int nMatchOffsetCost = (nMatchOffset == nRepOffset) ? 0 : nNoRepmatchOffsetCost; int nRepCodingChoiceCost = nPrevCost + 8 /* token */ /* the actual cost of the literals themselves accumulates up the chain */ + nMatchLenCost; int nCodingChoiceCost = nRepCodingChoiceCost + nMatchOffsetCost; - if (!nFavorRatio && !arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].num_literals) + if (!nFavorRatio && !arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].num_literals) nCodingChoiceCost += MODESWITCH_PENALTY; - if (nRepCodingChoiceCost <= pDestSlots[NMATCHES_PER_OFFSET - 1].cost) { - if (nCodingChoiceCost <= pDestSlots[NMATCHES_PER_OFFSET - 1].cost) { + if (nRepCodingChoiceCost <= pDestSlots[NMATCHES_PER_ARRIVAL - 1].cost) { + if (nCodingChoiceCost <= pDestSlots[NMATCHES_PER_ARRIVAL - 1].cost) { int exists = 0; for (n = 0; - n < NMATCHES_PER_OFFSET && pDestSlots[n].cost <= nCodingChoiceCost; + n < NMATCHES_PER_ARRIVAL && pDestSlots[n].cost <= nCodingChoiceCost; n++) { if (pDestSlots[n].rep_offset == nMatchOffset) { exists = 1; @@ -380,9 +389,9 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne } if (!exists) { - int nScore = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].score + ((nMatchOffset == nRepOffset) ? 2 : 3); + int nScore = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].score + ((nMatchOffset == nRepOffset) ? 2 : 3); - for (n = 0; n < NMATCHES_PER_OFFSET; n++) { + for (n = 0; n < NMATCHES_PER_ARRIVAL; n++) { lzsa_arrival *pDestArrival = &pDestSlots[n]; if (nCodingChoiceCost < pDestArrival->cost || @@ -390,7 +399,7 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne if (pDestArrival->from_slot) { memmove(&pDestSlots[n + 1], &pDestSlots[n], - sizeof(lzsa_arrival) * (NMATCHES_PER_OFFSET - n - 1)); + sizeof(lzsa_arrival) * (NMATCHES_PER_ARRIVAL - n - 1)); } pDestArrival->cost = nCodingChoiceCost; @@ -419,7 +428,7 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne /* A match is possible at the rep offset; insert the extra coding choice. */ for (n = 0; - n < NMATCHES_PER_OFFSET && pDestSlots[n].cost <= nRepCodingChoiceCost; + n < NMATCHES_PER_ARRIVAL && pDestSlots[n].cost <= nRepCodingChoiceCost; n++) { if (pDestSlots[n].rep_offset == nRepOffset) { exists = 1; @@ -428,9 +437,9 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne } if (!exists) { - int nScore = arrival[(i << MATCHES_PER_OFFSET_SHIFT) + j].score + 2; + int nScore = arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + j].score + 2; - for (n = 0; n < NMATCHES_PER_OFFSET; n++) { + for (n = 0; n < NMATCHES_PER_ARRIVAL; n++) { lzsa_arrival *pDestArrival = &pDestSlots[n]; if (nRepCodingChoiceCost < pDestArrival->cost || @@ -438,7 +447,7 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne if (pDestArrival->from_slot) { memmove(&pDestSlots[n + 1], &pDestSlots[n], - sizeof(lzsa_arrival) * (NMATCHES_PER_OFFSET - n - 1)); + sizeof(lzsa_arrival) * (NMATCHES_PER_ARRIVAL - n - 1)); } pDestArrival->cost = nRepCodingChoiceCost; @@ -462,14 +471,14 @@ static void lzsa_optimize_forward_v2(lzsa_compressor *pCompressor, const unsigne } } - lzsa_arrival *end_arrival = &arrival[(i << MATCHES_PER_OFFSET_SHIFT) + 0]; + lzsa_arrival *end_arrival = &arrival[(i << MATCHES_PER_ARRIVAL_SHIFT) + 0]; pBestMatch[i].length = 0; pBestMatch[i].offset = 0; while (end_arrival->from_slot > 0 && end_arrival->from_pos >= 0) { pBestMatch[end_arrival->from_pos].length = end_arrival->match_len; pBestMatch[end_arrival->from_pos].offset = end_arrival->match_offset; - end_arrival = &arrival[(end_arrival->from_pos << MATCHES_PER_OFFSET_SHIFT) + (end_arrival->from_slot - 1)]; + end_arrival = &arrival[(end_arrival->from_pos << MATCHES_PER_ARRIVAL_SHIFT) + (end_arrival->from_slot - 1)]; } } diff --git a/src/shrink_context.c b/src/shrink_context.c index a9bcc1e..7c37f57 100644 --- a/src/shrink_context.c +++ b/src/shrink_context.c @@ -89,7 +89,7 @@ int lzsa_compressor_init(lzsa_compressor *pCompressor, const int nMaxWindowSize, pCompressor->open_intervals = (unsigned int *)malloc((LCP_AND_TAG_MAX + 1) * sizeof(unsigned int)); if (pCompressor->open_intervals) { - pCompressor->arrival = (lzsa_arrival *)malloc(nMaxWindowSize * NMATCHES_PER_OFFSET * sizeof(lzsa_arrival)); + pCompressor->arrival = (lzsa_arrival *)malloc(nMaxWindowSize * NMATCHES_PER_ARRIVAL * sizeof(lzsa_arrival)); if (pCompressor->arrival) { pCompressor->best_match = (lzsa_match *)malloc(nMaxWindowSize * sizeof(lzsa_match)); @@ -99,9 +99,9 @@ int lzsa_compressor_init(lzsa_compressor *pCompressor, const int nMaxWindowSize, if (pCompressor->improved_match) { if (pCompressor->format_version == 2) - pCompressor->match = (lzsa_match *)malloc(nMaxWindowSize * 32 * sizeof(lzsa_match)); + pCompressor->match = (lzsa_match *)malloc(nMaxWindowSize * NMATCHES_PER_INDEX_V2 * sizeof(lzsa_match)); else - pCompressor->match = (lzsa_match *)malloc(nMaxWindowSize * 8 * sizeof(lzsa_match)); + pCompressor->match = (lzsa_match *)malloc(nMaxWindowSize * NMATCHES_PER_INDEX_V1 * sizeof(lzsa_match)); if (pCompressor->match) return 0; } @@ -185,7 +185,7 @@ int lzsa_compressor_shrink_block(lzsa_compressor *pCompressor, unsigned char *pI if (nPreviousBlockSize) { lzsa_skip_matches(pCompressor, 0, nPreviousBlockSize); } - lzsa_find_all_matches(pCompressor, (pCompressor->format_version == 2) ? 32 : 8, nPreviousBlockSize, nPreviousBlockSize + nInDataSize); + lzsa_find_all_matches(pCompressor, (pCompressor->format_version == 2) ? NMATCHES_PER_INDEX_V2 : NMATCHES_PER_INDEX_V1, nPreviousBlockSize, nPreviousBlockSize + nInDataSize); if (pCompressor->format_version == 1) { nCompressedSize = lzsa_optimize_and_write_block_v1(pCompressor, pInWindow, nPreviousBlockSize, nInDataSize, pOutData, nMaxOutDataSize); diff --git a/src/shrink_context.h b/src/shrink_context.h index 5872b59..7ac3284 100644 --- a/src/shrink_context.h +++ b/src/shrink_context.h @@ -49,8 +49,14 @@ extern "C" { #define VISITED_FLAG 0x80000000 #define EXCL_VISITED_MASK 0x7fffffff -#define NMATCHES_PER_OFFSET 8 -#define MATCHES_PER_OFFSET_SHIFT 3 +#define NMATCHES_PER_ARRIVAL 8 +#define MATCHES_PER_ARRIVAL_SHIFT 3 + +#define NMATCHES_PER_INDEX_V1 8 +#define MATCHES_PER_INDEX_SHIFT_V1 3 + +#define NMATCHES_PER_INDEX_V2 32 +#define MATCHES_PER_INDEX_SHIFT_V2 5 #define LEAVE_ALONE_MATCH_SIZE 1000