void initPropRanges(Ranges &propRanges, const ColorRanges &ranges, int p) {
propRanges.clear();
int min = ranges.min(p);
int max = ranges.max(p);
int mind = min - max, maxd = max - min;
if (p < 3) { // alpha channel first
for (int pp = 0; pp < p; pp++) {
propRanges.push_back(std::make_pair(ranges.min(pp), ranges.max(pp))); // pixels on previous planes
}
if (ranges.numPlanes()>3) propRanges.push_back(std::make_pair(ranges.min(3), ranges.max(3))); // pixel on alpha plane
}
//if (p<1 || p>2)
propRanges.push_back(std::make_pair(0,2)); // median predictor: which of the three values is the median?
if (p==1 || p==2) propRanges.push_back(std::make_pair(ranges.min(0)-ranges.max(0),ranges.max(0)-ranges.min(0))); // luma prediction miss
propRanges.push_back(std::make_pair(mind,maxd)); // neighbor A - neighbor B (top-bottom or left-right)
propRanges.push_back(std::make_pair(mind,maxd)); // top/left prediction miss (previous pixel)
propRanges.push_back(std::make_pair(mind,maxd)); // left/top prediction miss (other direction)
propRanges.push_back(std::make_pair(mind,maxd)); // bottom/right prediction miss
propRanges.push_back(std::make_pair(min,max)); // guess
// propRanges.push_back(std::make_pair(mind,maxd)); // left - topleft
// propRanges.push_back(std::make_pair(mind,maxd)); // topleft - top
// if (p == 0 || p > 2)
// propRanges.push_back(std::make_pair(mind,maxd)); // top - topright
if (p != 2) {
propRanges.push_back(std::make_pair(mind,maxd)); // toptop - top
propRanges.push_back(std::make_pair(mind,maxd)); // leftleft - left
}
}
void invData(Images& images) const override {
ColorVal R,G,B,Y,C1,C2;
const ColorVal max[3] = {ranges->max(0), ranges->max(1), ranges->max(2)};
for (Image& image : images) {
image.undo_make_constant_plane(0);
image.undo_make_constant_plane(1);
image.undo_make_constant_plane(2);
for (uint32_t r=0; r<image.rows(); r++) {
for (uint32_t c=0; c<image.cols(); c++) {
Y=image(0,r,c);
C1=image(1,r,c);
C2=image(2,r,c);
G = Y - (-2*C2)/3;
clip(G, 0, max[1]);
B = G - C2 - C1/2;
clip(B, 0, max[2]);
R = B + C1;
clip(R, 0, max[0]); // clipping only needed in case of lossy/partial decoding
image.set(0,r,c, R);
image.set(1,r,c, G);
image.set(2,r,c, B);
}
}
}
}
ColorVal max(int p) const { switch(p) {
case 0: return 4*par-1;
case 1: return 8*par-2;
case 2: return 8*par-2;
default: return ranges->max(p);
};
}
ColorVal max(int p) const { switch(p) {
case 0: return 0;
case 1: return nb_colors-1;
case 2: return 0;
default: return ranges->max(p);
};
}
ColorVal max(int p) const {
switch(p) {
case 0: return maximum;
case 1: return maximum;
case 2: return maximum;
default: return ranges->max(p);
};
}
void initPropRanges_scanlines(Ranges &propRanges, const ColorRanges &ranges, int p) {
propRanges.clear();
int min = ranges.min(p);
int max = ranges.max(p);
int mind = min - max, maxd = max - min;
if (p < 3) {
for (int pp = 0; pp < p; pp++) {
propRanges.push_back(std::make_pair(ranges.min(pp), ranges.max(pp))); // pixels on previous planes
}
if (ranges.numPlanes()>3) propRanges.push_back(std::make_pair(ranges.min(3), ranges.max(3))); // pixel on alpha plane
}
propRanges.push_back(std::make_pair(min,max)); // guess (median of 3)
propRanges.push_back(std::make_pair(0,2)); // which predictor was it
propRanges.push_back(std::make_pair(mind,maxd));
propRanges.push_back(std::make_pair(mind,maxd));
propRanges.push_back(std::make_pair(mind,maxd));
propRanges.push_back(std::make_pair(mind,maxd));
propRanges.push_back(std::make_pair(mind,maxd));
}
void initPropRanges(Ranges &propRanges, const ColorRanges &ranges, int p) {
propRanges.clear();
int min = ranges.min(p);
int max = ranges.max(p);
int mind = min - max, maxd = max - min;
if (p < 3) { // alpha channel first
for (int pp = 0; pp < p; pp++) {
propRanges.push_back(std::make_pair(ranges.min(pp), ranges.max(pp))); // pixels on previous planes
}
if (ranges.numPlanes()>3) propRanges.push_back(std::make_pair(ranges.min(3), ranges.max(3))); // pixel on alpha plane
}
propRanges.push_back(std::make_pair(mind,maxd)); // neighbor A - neighbor B (top-bottom or left-right)
propRanges.push_back(std::make_pair(min,max)); // guess (median of 3)
propRanges.push_back(std::make_pair(0,2)); // which predictor was it
propRanges.push_back(std::make_pair(mind,maxd));
propRanges.push_back(std::make_pair(mind,maxd));
propRanges.push_back(std::make_pair(mind,maxd));
if (p < 2 || p >= 3) {
propRanges.push_back(std::make_pair(mind,maxd));
propRanges.push_back(std::make_pair(mind,maxd));
}
}
bool exists(const int p, const prevPlanes &pp) const {
if (p>0 && (pp[0] < min0 || pp[0] > ranges->max(0))) return false;
if (p>1 && (pp[1] < min1 || pp[1] > ranges->max(1))) return false;
ColorVal rmin, rmax;
ColorVal v=pp[p];
ranges->snap(p,pp,rmin,rmax,v);
if (v != pp[p]) return false; // bucket empty because of original range constraints
const ColorBucket b = findBucket(p,pp);
//if (b.min > b.max) return false;
if (b.snapColor_slow(pp[p]) != pp[p]) return false;
return true;
}
ColorVal max(int p) const override { return ranges->max(p); }
ColorVal max(int p) const { return ranges->max(p); }
ColorVal max(int p) const { assert(p<numPlanes()); return std::min(ranges->max(p), bounds[p].second); }
ColorVal max(int p) const { if (p<3) return ranges->max(p); else if (p==3) return alpha_max; else return numPrevFrames; }
void minmax(const int p, const prevPlanes &pp, ColorVal &minv, ColorVal &maxv) const override {
if (p==0 || p>2) { minv = min(p); maxv = max(p); }
else { minv = ranges->min(permutation[p])-pp[0]; maxv = ranges->max(permutation[p])-pp[0]; }
}
ColorVal max(int p) const override { if (p==0 || p>2) return ranges->max(permutation[p]); else return ranges->max(permutation[p])-ranges->min(permutation[0]); }
ColorVal max(int p) const override { return ranges->max(permutation[p]); }
void invData(Images& images) const override {
ColorVal pixel[5];
for (Image& image : images) {
for (int p=0; p<ranges->numPlanes(); p++) image.undo_make_constant_plane(p);
for (uint32_t r=0; r<image.rows(); r++) {
for (uint32_t c=0; c<image.cols(); c++) {
for (int p=0; p<ranges->numPlanes(); p++) pixel[p] = image(p,r,c);
for (int p=0; p<ranges->numPlanes(); p++) image.set(permutation[p],r,c, pixel[p]);
image.set(permutation[0],r,c, pixel[0]);
if (!subtract) { for (int p=1; p<ranges->numPlanes(); p++) image.set(permutation[p],r,c, pixel[p]); }
else { for (int p=1; p<3 && p<ranges->numPlanes(); p++) image.set(permutation[p],r,c, CLAMP(pixel[p] + pixel[0], ranges->min(permutation[p]), ranges->max(permutation[p])));
for (int p=3; p<ranges->numPlanes(); p++) image.set(permutation[p],r,c, pixel[p]); }
}
}
}
}