From 422bd247103c3878bebd3df673fa28739f1052c9 Mon Sep 17 00:00:00 2001 From: Mathis Rosenhauer Date: Sun, 23 Sep 2012 22:32:07 +0200 Subject: [PATCH] Remove skipping as it doesn't help much if any --- src/encode.c | 72 ++++++++++++++++++---------------------------------- 1 file changed, 24 insertions(+), 48 deletions(-) diff --git a/src/encode.c b/src/encode.c index 110c5c2..d16d2c6 100644 --- a/src/encode.c +++ b/src/encode.c @@ -358,33 +358,20 @@ static int count_splitting_option(struct aec_stream *strm) CDS length, we start with the k of the previous CDS. K is increased and the CDS length evaluated. If the CDS length gets smaller, then we are moving towards the minimum. If the length - increases, then the minimum will be found with smaller k. Two - additional checks are used to speed up the process: - - 1. If we are increasing k to find the minimum then we know that - k+1 will at most eliminate the FS part. OTOH we gain block_size - bits in length through the increased binary part. So if the FS - lenth is already less than the block size then the length of - the CDS for k+1 will be larger than for k. The same can be done - for decreasing k. - - 2. If 1. is not the case then we have to continue looking. The - next step would be to increase k by one and evaluate the CDS - length. A lower limit for the k+1 FS length is - 0.5*(FS_len-block_size). If half of that is more than - block_size then we can skip k+1 altogether. This reduces to the - condition: - - if (fs_len > 5 * block_size) - k++; - - We can be repeat this step while the condition is met to skip - several k. + increases, then the minimum will be found with smaller k. + + For increasing k we know that we will gain block_size bits in + length through the larger binary part. If the FS lenth is less + than the block size then a reduced FS part can't compensate the + larger binary part. So we know that the CDS for k+1 will be + larger than for k without actually computing the length. An + analogue check can be done for decreasing k. + */ int k, k_min; int this_bs; /* Block size of current block */ - int min_dir; /* 1 if we saw a decrease in CDS length */ + int no_turn; /* 1 if we shouldn't reverse */ int dir; /* Direction, 1 means increasing k, 0 decreasing k */ uint64_t len; /* CDS length for current k */ uint64_t len_min; /* CDS length minimum so far */ @@ -395,8 +382,8 @@ static int count_splitting_option(struct aec_stream *strm) this_bs = strm->block_size - state->ref; len_min = UINT64_MAX; k = k_min = state->k; + no_turn = (k == 0) ? 1 : 0; dir = 1; - min_dir = 0; for (;;) { fs_len = block_fs(strm, k); @@ -404,43 +391,32 @@ static int count_splitting_option(struct aec_stream *strm) if (len < len_min) { if (len_min < UINT64_MAX) - min_dir = 1; + no_turn = 1; len_min = len; k_min = k; if (dir) { - if (fs_len < this_bs) { - goto reverse; - } else { - while (fs_len > 5 * this_bs) { - k++; - fs_len /= 5; - } + if (fs_len < this_bs || k >= state->kmax) { + if (no_turn) + break; + k = state->k - 1; + dir = 0; + no_turn = 1; } - - if (k >= state->kmax) - goto reverse; - else - k++; + k++; } else { if (fs_len >= this_bs || k == 0) break; - k--; } } else { - goto reverse; + if (no_turn) + break; + k = state->k - 1; + dir = 0; + no_turn = 1; } - continue; - - reverse: - if (min_dir || state->k == 0) - break; - - k = state->k - 1; - dir = 0; - min_dir = 1; } state->k = k_min; -- GitLab