static void FinalizePSNR(const VP8Encoder* const enc) {
WebPAuxStats* stats = enc->pic_->stats;
const uint64_t size = enc->sse_count_;
const uint64_t* const sse = enc->sse_;
stats->PSNR[0] = (float)GetPSNR(sse[0], size);
stats->PSNR[1] = (float)GetPSNR(sse[1], size / 4);
stats->PSNR[2] = (float)GetPSNR(sse[2], size / 4);
stats->PSNR[3] = (float)GetPSNR(sse[0] + sse[1] + sse[2], size * 3 / 2);
}
int WebPPictureDistortion(const WebPPicture* src, const WebPPicture* ref,
int type, float results[5]) {
int w, h, c;
int ok = 0;
WebPPicture p0, p1;
double total_size = 0., total_distortion = 0.;
if (src == NULL || ref == NULL ||
src->width != ref->width || src->height != ref->height ||
results == NULL) {
return 0;
}
VP8SSIMDspInit();
if (!WebPPictureInit(&p0) || !WebPPictureInit(&p1)) return 0;
w = src->width;
h = src->height;
if (!WebPPictureView(src, 0, 0, w, h, &p0)) goto Error;
if (!WebPPictureView(ref, 0, 0, w, h, &p1)) goto Error;
// We always measure distortion in ARGB space.
if (p0.use_argb == 0 && !WebPPictureYUVAToARGB(&p0)) goto Error;
if (p1.use_argb == 0 && !WebPPictureYUVAToARGB(&p1)) goto Error;
for (c = 0; c < 4; ++c) {
float distortion;
const size_t stride0 = 4 * (size_t)p0.argb_stride;
const size_t stride1 = 4 * (size_t)p1.argb_stride;
if (!WebPPlaneDistortion((const uint8_t*)p0.argb + c, stride0,
(const uint8_t*)p1.argb + c, stride1,
w, h, 4, type, &distortion, results + c)) {
goto Error;
}
total_distortion += distortion;
total_size += w * h;
}
results[4] = (type == 1) ? (float)GetLogSSIM(total_distortion, total_size)
: (float)GetPSNR(total_distortion, total_size);
ok = 1;
Error:
WebPPictureFree(&p0);
WebPPictureFree(&p1);
return ok;
}
int WebPPlaneDistortion(const uint8_t* src, size_t src_stride,
const uint8_t* ref, size_t ref_stride,
int width, int height, size_t x_step,
int type, float* distortion, float* result) {
uint8_t* allocated = NULL;
const AccumulateFunc metric = (type == 0) ? AccumulateSSE :
(type == 1) ? AccumulateSSIM :
AccumulateLSIM;
if (src == NULL || ref == NULL ||
src_stride < x_step * width || ref_stride < x_step * width ||
result == NULL || distortion == NULL) {
return 0;
}
VP8SSIMDspInit();
if (x_step != 1) { // extract a packed plane if needed
int x, y;
uint8_t* tmp1;
uint8_t* tmp2;
allocated =
(uint8_t*)WebPSafeMalloc(2ULL * width * height, sizeof(*allocated));
if (allocated == NULL) return 0;
tmp1 = allocated;
tmp2 = tmp1 + (size_t)width * height;
for (y = 0; y < height; ++y) {
for (x = 0; x < width; ++x) {
tmp1[x + y * width] = src[x * x_step + y * src_stride];
tmp2[x + y * width] = ref[x * x_step + y * ref_stride];
}
}
src = tmp1;
ref = tmp2;
}
*distortion = (float)metric(src, width, ref, width, width, height);
WebPSafeFree(allocated);
*result = (type == 1) ? (float)GetLogSSIM(*distortion, (double)width * height)
: (float)GetPSNR(*distortion, (double)width * height);
return 1;
}
