my_type redundant(int *new_clause, int *old_clause) {
int lit1, lit2, old_clause_diff=0, new_clause_diff=0;
lit1=*old_clause; lit2=*new_clause;
while ((lit1 != NONE) && (lit2 != NONE)) {
if (smaller_than(lit1, lit2)) {
lit1=*(++old_clause); old_clause_diff++;
}
else
if (smaller_than(lit2, lit1)) {
lit2=*(++new_clause); new_clause_diff++;
}
else
if (complement(lit1, lit2)) {
return FALSE; /* old_clause_diff++; new_clause_diff++; j1++; j2++; */
}
else {
lit1=*(++old_clause); lit2=*(++new_clause);
}
}
if ((lit1 == NONE) && (old_clause_diff == 0))
/* la nouvelle clause est redondante ou subsumee */
return NEW_CLAUSE_REDUNDANT;
if ((lit2 == NONE) && (new_clause_diff == 0))
/* la old clause est redondante ou subsumee */
return OLD_CLAUSE_REDUNDANT;
return FALSE;
}
int SkAndroidCodec::computeSampleSize(SkISize* desiredSize) const {
SkASSERT(desiredSize);
if (!desiredSize || *desiredSize == fInfo.dimensions()) {
return 1;
}
if (smaller_than(fInfo.dimensions(), *desiredSize)) {
*desiredSize = fInfo.dimensions();
return 1;
}
// Handle bad input:
if (desiredSize->width() < 1 || desiredSize->height() < 1) {
*desiredSize = SkISize::Make(std::max(1, desiredSize->width()),
std::max(1, desiredSize->height()));
}
if (supports_any_down_scale(fCodec.get())) {
return 1;
}
int sampleX = fInfo.width() / desiredSize->width();
int sampleY = fInfo.height() / desiredSize->height();
int sampleSize = std::min(sampleX, sampleY);
auto computedSize = this->getSampledDimensions(sampleSize);
if (computedSize == *desiredSize) {
return sampleSize;
}
if (computedSize == fInfo.dimensions() || sampleSize == 1) {
// Cannot downscale
*desiredSize = computedSize;
return 1;
}
if (strictly_bigger_than(computedSize, *desiredSize)) {
// See if there is a tighter fit.
while (true) {
auto smaller = this->getSampledDimensions(sampleSize + 1);
if (smaller == *desiredSize) {
return sampleSize + 1;
}
if (smaller == computedSize || smaller_than(smaller, *desiredSize)) {
// Cannot get any smaller without being smaller than desired.
*desiredSize = computedSize;
return sampleSize;
}
sampleSize++;
computedSize = smaller;
}
SkASSERT(false);
}
if (!smaller_than(computedSize, *desiredSize)) {
// This means one of the computed dimensions is equal to desired, and
// the other is bigger. This is as close as we can get.
*desiredSize = computedSize;
return sampleSize;
}
// computedSize is too small. Make it larger.
while (sampleSize > 2) {
auto bigger = this->getSampledDimensions(sampleSize - 1);
if (bigger == *desiredSize || !smaller_than(bigger, *desiredSize)) {
*desiredSize = bigger;
return sampleSize - 1;
}
sampleSize--;
}
*desiredSize = fInfo.dimensions();
return 1;
}
